libgems 0.0.1

data/lib/libgems/dependency_list.rb

@@ -0,0 +1,208 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'tsort'
+
+##
+# LibGems::DependencyList is used for installing and uninstalling gems in the
+# correct order to avoid conflicts.
+
+class LibGems::DependencyList
+
+  include Enumerable
+  include TSort
+
+  ##
+  # Allows enabling/disabling use of development dependencies
+
+  attr_accessor :development
+
+  ##
+  # Creates a DependencyList from a LibGems::SourceIndex +source_index+
+
+  def self.from_source_index(source_index)
+    list = new
+
+    source_index.each do |full_name, spec|
+      list.add spec
+    end
+
+    list
+  end
+
+  ##
+  # Creates a new DependencyList.  If +development+ is true, development
+  # dependencies will be included.
+
+  def initialize development = false
+    @specs = []
+
+    @development = development
+  end
+
+  ##
+  # Adds +gemspecs+ to the dependency list.
+
+  def add(*gemspecs)
+    @specs.push(*gemspecs)
+  end
+
+  ##
+  # Return a list of the gem specifications in the dependency list, sorted in
+  # order so that no gemspec in the list depends on a gemspec earlier in the
+  # list.
+  #
+  # This is useful when removing gems from a set of installed gems.  By
+  # removing them in the returned order, you don't get into as many dependency
+  # issues.
+  #
+  # If there are circular dependencies (yuck!), then gems will be returned in
+  # order until only the circular dependents and anything they reference are
+  # left.  Then arbitrary gemspecs will be returned until the circular
+  # dependency is broken, after which gems will be returned in dependency
+  # order again.
+
+  def dependency_order
+    sorted = strongly_connected_components.flatten
+
+    result = []
+    seen = {}
+
+    sorted.each do |spec|
+      if index = seen[spec.name] then
+        if result[index].version < spec.version then
+          result[index] = spec
+        end
+      else
+        seen[spec.name] = result.length
+        result << spec
+      end
+    end
+
+    result.reverse
+  end
+
+  ##
+  # Iterator over dependency_order
+
+  def each(&block)
+    dependency_order.each(&block)
+  end
+
+  def find_name(full_name)
+    @specs.find { |spec| spec.full_name == full_name }
+  end
+
+  def inspect # :nodoc:
+    "#<%s:0x%x %p>" % [self.class, object_id, map { |s| s.full_name }]
+  end
+
+  ##
+  # Are all the dependencies in the list satisfied?
+
+  def ok?
+    @specs.all? do |spec|
+      spec.runtime_dependencies.all? do |dep|
+        @specs.find { |s| s.satisfies_requirement? dep }
+      end
+    end
+  end
+
+  ##
+  # Is is ok to remove a gemspec from the dependency list?
+  #
+  # If removing the gemspec creates breaks a currently ok dependency, then it
+  # is NOT ok to remove the gemspec.
+
+  def ok_to_remove?(full_name)
+    gem_to_remove = find_name full_name
+
+    siblings = @specs.find_all { |s|
+      s.name == gem_to_remove.name &&
+        s.full_name != gem_to_remove.full_name
+    }
+
+    deps = []
+
+    @specs.each do |spec|
+      spec.dependencies.each do |dep|
+        deps << dep if gem_to_remove.satisfies_requirement?(dep)
+      end
+    end
+
+    deps.all? { |dep|
+      siblings.any? { |s|
+        s.satisfies_requirement? dep
+      }
+    }
+  end
+
+  ##
+  # Removes the gemspec matching +full_name+ from the dependency list
+
+  def remove_by_name(full_name)
+    @specs.delete_if { |spec| spec.full_name == full_name }
+  end
+
+  ##
+  # Return a hash of predecessors.  <tt>result[spec]</tt> is an Array of
+  # gemspecs that have a dependency satisfied by the named gemspec.
+
+  def spec_predecessors
+    result = Hash.new { |h,k| h[k] = [] }
+
+    specs = @specs.sort.reverse
+
+    specs.each do |spec|
+      specs.each do |other|
+        next if spec == other
+
+        other.dependencies.each do |dep|
+          if spec.satisfies_requirement? dep then
+            result[spec] << other
+          end
+        end
+      end
+    end
+
+    result
+  end
+
+  def tsort_each_node(&block)
+    @specs.each(&block)
+  end
+
+  def tsort_each_child(node, &block)
+    specs = @specs.sort.reverse
+
+    dependencies = node.runtime_dependencies
+    dependencies.push(*node.development_dependencies) if @development
+
+    dependencies.each do |dep|
+      specs.each do |spec|
+        if spec.satisfies_requirement? dep then
+          begin
+            yield spec
+          rescue TSort::Cyclic
+          end
+          break
+        end
+      end
+    end
+  end
+
+  private
+
+  ##
+  # Count the number of gemspecs in the list +specs+ that are not in
+  # +ignored+.
+
+  def active_count(specs, ignored)
+    specs.count { |spec| ignored[spec.full_name].nil? }
+  end
+
+end
+

data/lib/libgems/doc_manager.rb

@@ -0,0 +1,242 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'fileutils'
+require 'libgems'
+
+##
+# The documentation manager generates RDoc and RI for SlimGems.
+
+class LibGems::DocManager
+
+  include LibGems::UserInteraction
+
+  @configured_args = []
+
+  def self.configured_args
+    @configured_args ||= []
+  end
+
+  def self.configured_args=(args)
+    case args
+    when Array
+      @configured_args = args
+    when String
+      @configured_args = args.split
+    end
+  end
+
+  ##
+  # Load RDoc from a gem if it is available, otherwise from Ruby's stdlib
+
+  def self.load_rdoc
+    begin
+      gem 'rdoc'
+    rescue LibGems::LoadError
+      # use built-in RDoc
+    end
+
+    begin
+      require 'rdoc/rdoc'
+
+      @rdoc_version = if defined? RDoc::VERSION then
+                        LibGems::Version.new RDoc::VERSION
+                      else
+                        LibGems::Version.new '1.0.1' # HACK parsing is hard
+                      end
+
+    rescue LoadError => e
+      raise LibGems::DocumentError,
+          "ERROR: RDoc documentation generator not installed: #{e}"
+    end
+  end
+
+  def self.rdoc_version
+    @rdoc_version
+  end
+
+  ##
+  # Updates the RI cache for RDoc 2 if it is installed
+
+  def self.update_ri_cache
+    load_rdoc rescue return
+
+    return unless defined? RDoc::VERSION # RDoc 1 does not have VERSION
+
+    require 'rdoc/ri/driver'
+
+    options = {
+      :use_cache => true,
+      :use_system => true,
+      :use_site => true,
+      :use_home => true,
+      :use_gems => true,
+      :formatter => RDoc::RI::Formatter,
+    }
+
+    RDoc::RI::Driver.new(options).class_cache
+  end
+
+  ##
+  # Create a document manager for +spec+. +rdoc_args+ contains arguments for
+  # RDoc (template etc.) as a String.
+
+  def initialize(spec, rdoc_args="")
+    @spec = spec
+    @doc_dir = File.join(spec.installation_path, "doc", spec.full_name)
+    @rdoc_args = rdoc_args.nil? ? [] : rdoc_args.split
+  end
+
+  ##
+  # Is the RDoc documentation installed?
+
+  def rdoc_installed?
+    File.exist?(File.join(@doc_dir, "rdoc"))
+  end
+
+  ##
+  # Is the RI documentation installed?
+
+  def ri_installed?
+    File.exist?(File.join(@doc_dir, "ri"))
+  end
+
+  ##
+  # Generate the RI documents for this gem spec.
+  #
+  # Note that if both RI and RDoc documents are generated from the same
+  # process, the RI docs should be done first (a likely bug in RDoc will cause
+  # RI docs generation to fail if run after RDoc).
+
+  def generate_ri
+    setup_rdoc
+    install_ri # RDoc bug, ri goes first
+
+    FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
+  end
+
+  ##
+  # Generate the RDoc documents for this gem spec.
+  #
+  # Note that if both RI and RDoc documents are generated from the same
+  # process, the RI docs should be done first (a likely bug in RDoc will cause
+  # RI docs generation to fail if run after RDoc).
+
+  def generate_rdoc
+    setup_rdoc
+    install_rdoc
+
+    FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
+  end
+
+  ##
+  # Generate and install RDoc into the documentation directory
+
+  def install_rdoc
+    rdoc_dir = File.join @doc_dir, 'rdoc'
+
+    FileUtils.rm_rf rdoc_dir
+
+    say "Installing RDoc documentation for #{@spec.full_name}..."
+    run_rdoc '--op', rdoc_dir
+  end
+
+  ##
+  # Generate and install RI into the documentation directory
+
+  def install_ri
+    ri_dir = File.join @doc_dir, 'ri'
+
+    FileUtils.rm_rf ri_dir
+
+    say "Installing ri documentation for #{@spec.full_name}..."
+    run_rdoc '--ri', '--op', ri_dir
+  end
+
+  ##
+  # Run RDoc with +args+, which is an ARGV style argument list
+
+  def run_rdoc(*args)
+    args << @spec.rdoc_options
+    args << self.class.configured_args
+    args << '--quiet'
+    args << @spec.require_paths.clone
+    args << @spec.extra_rdoc_files
+    args << '--title' << "#{@spec.full_name} Documentation"
+    args = args.flatten.map do |arg| arg.to_s end
+
+    if self.class.rdoc_version >= LibGems::Version.new('2.4.0') then
+      args.delete '--inline-source'
+      args.delete '--promiscuous'
+      args.delete '-p'
+      args.delete '--one-file'
+      # HACK more
+    end
+
+    r = RDoc::RDoc.new
+
+    old_pwd = Dir.pwd
+    Dir.chdir @spec.full_gem_path
+
+    say "rdoc #{args.join ' '}" if LibGems.configuration.really_verbose
+
+    begin
+      r.document args
+    rescue Errno::EACCES => e
+      dirname = File.dirname e.message.split("-")[1].strip
+      raise LibGems::FilePermissionError.new(dirname)
+    rescue Interrupt => e
+      raise e
+    rescue Exception => ex
+      alert_error "While generating documentation for #{@spec.full_name}"
+      ui.errs.puts "... MESSAGE:   #{ex}"
+      ui.errs.puts "... RDOC args: #{args.join(' ')}"
+      ui.errs.puts "\t#{ex.backtrace.join "\n\t"}" if
+      LibGems.configuration.backtrace
+      ui.errs.puts "(continuing with the rest of the installation)"
+    ensure
+      Dir.chdir old_pwd
+    end
+  end
+
+  def setup_rdoc
+    if File.exist?(@doc_dir) && !File.writable?(@doc_dir) then
+      raise LibGems::FilePermissionError.new(@doc_dir)
+    end
+
+    FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
+
+    self.class.load_rdoc
+  end
+
+  ##
+  # Remove RDoc and RI documentation
+
+  def uninstall_doc
+    raise LibGems::FilePermissionError.new(@spec.installation_path) unless
+    File.writable? @spec.installation_path
+
+    original_name = [
+      @spec.name, @spec.version, @spec.original_platform].join '-'
+
+    doc_dir = File.join @spec.installation_path, 'doc', @spec.full_name
+    unless File.directory? doc_dir then
+      doc_dir = File.join @spec.installation_path, 'doc', original_name
+    end
+
+    FileUtils.rm_rf doc_dir
+
+    ri_dir = File.join @spec.installation_path, 'ri', @spec.full_name
+
+    unless File.directory? ri_dir then
+      ri_dir = File.join @spec.installation_path, 'ri', original_name
+    end
+
+    FileUtils.rm_rf ri_dir
+  end
+
+end
+

data/lib/libgems/errors.rb

@@ -0,0 +1,35 @@
+class LibGems::ErrorReason; end
+
+# Generated when trying to lookup a gem to indicate that the gem
+# was found, but that it isn't usable on the current platform.
+#
+# fetch and install read these and report them to the user to aid
+# in figuring out why a gem couldn't be installed.
+#
+class LibGems::PlatformMismatch < LibGems::ErrorReason
+
+  attr_reader :name
+  attr_reader :version
+  attr_reader :platforms
+
+  def initialize(name, version)
+    @name = name
+    @version = version
+    @platforms = []
+  end
+
+  def add_platform(platform)
+    @platforms << platform
+  end
+
+  def wordy
+    prefix = "Found #{@name} (#{@version})"
+
+    if @platforms.size == 1
+      "#{prefix}, but was for platform #{@platforms[0]}"
+    else
+      "#{prefix}, but was for platforms #{@platforms.join(' ,')}"
+    end
+  end
+
+end