libgems 0.0.1

data/lib/libgems/commands/unpack_command.rb

@@ -0,0 +1,121 @@
+require 'fileutils'
+require 'libgems/command'
+require 'libgems/installer'
+require 'libgems/version_option'
+
+class LibGems::Commands::UnpackCommand < LibGems::Command
+
+  include LibGems::VersionOption
+
+  def initialize
+    super 'unpack', 'Unpack an installed gem to the current directory',
+          :version => LibGems::Requirement.default,
+          :target  => Dir.pwd
+
+    add_option('--target=DIR',
+               'target directory for unpacking') do |value, options|
+      options[:target] = value
+    end
+
+    add_version_option
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to unpack"
+  end
+
+  def defaults_str # :nodoc:
+    "--version '#{LibGems::Requirement.default}'"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME"
+  end
+
+  def download dependency
+    found = LibGems::SpecFetcher.fetcher.fetch dependency
+
+    return if found.empty?
+
+    spec, source_uri = found.first
+
+    LibGems::RemoteFetcher.fetcher.download spec, source_uri
+  end
+
+  #--
+  # TODO: allow, e.g., 'gem unpack rake-0.3.1'.  Find a general solution for
+  # this, so that it works for uninstall as well.  (And check other commands
+  # at the same time.)
+
+  def execute
+    get_all_gem_names.each do |name|
+      dependency = LibGems::Dependency.new name, options[:version]
+      path = get_path dependency
+
+      if path then
+        basename = File.basename path, '.gem'
+        target_dir = File.expand_path basename, options[:target]
+        FileUtils.mkdir_p target_dir
+        LibGems::Installer.new(path, :unpack => true).unpack target_dir
+        say "Unpacked gem: '#{target_dir}'"
+      else
+        alert_error "Gem '#{name}' not installed."
+      end
+    end
+  end
+
+  ##
+  #
+  # Find cached filename in LibGems.path. Returns nil if the file cannot be found.
+  #
+  #--
+  # TODO: see comments in get_path() about general service.
+
+  def find_in_cache(filename)
+    LibGems.path.each do |gem_dir|
+      this_path = File.join gem_dir, 'cache', filename
+      return this_path if File.exist? this_path
+    end
+
+    return nil
+  end
+
+  ##
+  # Return the full path to the cached gem file matching the given
+  # name and version requirement.  Returns 'nil' if no match.
+  #
+  # Example:
+  #
+  #   get_path 'rake', '> 0.4' # "/usr/lib/ruby/gems/1.8/cache/rake-0.4.2.gem"
+  #   get_path 'rake', '< 0.1' # nil
+  #   get_path 'rak'           # nil (exact name required)
+  #--
+  # TODO: This should be refactored so that it's a general service. I don't
+  # think any of our existing classes are the right place though.  Just maybe
+  # 'Cache'?
+  #
+  # TODO: It just uses LibGems.dir for now.  What's an easy way to get the list of
+  # source directories?
+
+  def get_path dependency
+    return dependency.name if dependency.name =~ /\.gem$/i
+
+    specs = LibGems.source_index.search dependency
+
+    selected = specs.sort_by { |s| s.version }.last
+
+    return download(dependency) if selected.nil?
+
+    return unless dependency.name =~ /^#{selected.name}$/i
+
+    # We expect to find (basename).gem in the 'cache' directory.  Furthermore,
+    # the name match must be exact (ignoring case).
+    
+    path = find_in_cache(selected.file_name)
+    return download(dependency) unless path
+
+    path
+  end
+
+end
+

data/lib/libgems/commands/update_command.rb

@@ -0,0 +1,160 @@
+require 'libgems/command'
+require 'libgems/command_manager'
+require 'libgems/install_update_options'
+require 'libgems/local_remote_options'
+require 'libgems/spec_fetcher'
+require 'libgems/version_option'
+require 'libgems/commands/install_command'
+
+class LibGems::Commands::UpdateCommand < LibGems::Command
+
+  include LibGems::InstallUpdateOptions
+  include LibGems::LocalRemoteOptions
+  include LibGems::VersionOption
+
+  def initialize
+    super 'update',
+          'Update the named gems (or all installed gems) in the local repository',
+      :generate_rdoc => true,
+      :generate_ri   => true,
+      :force         => false,
+      :test          => false
+
+    add_install_update_options
+
+    OptionParser.accept LibGems::Version do |value|
+      LibGems::Version.new value
+
+      value
+    end
+
+    add_local_remote_options
+    add_platform_option
+    add_prerelease_option "as update targets"
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to update"
+  end
+
+  def defaults_str # :nodoc:
+    "--rdoc --ri --no-force --no-test --install-dir #{LibGems.dir}"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME [GEMNAME ...]"
+  end
+
+  def execute
+    @installer = LibGems::DependencyInstaller.new options
+    @updated   = []
+
+    hig = {}
+
+    say "Updating installed gems"
+
+    hig = {} # highest installed gems
+
+    LibGems.source_index.each do |name, spec|
+      if hig[spec.name].nil? or hig[spec.name].version < spec.version then
+        hig[spec.name] = spec
+      end
+    end
+
+    gems_to_update = which_to_update hig, options[:args]
+
+    updated = update_gems gems_to_update
+
+    if updated.empty? then
+      say "Nothing to update"
+    else
+      say "Gems updated: #{updated.map { |spec| spec.name }.join ', '}"
+
+      if options[:generate_ri] then
+        updated.each do |gem|
+          LibGems::DocManager.new(gem, options[:rdoc_args]).generate_ri
+        end
+
+        LibGems::DocManager.update_ri_cache
+      end
+
+      if options[:generate_rdoc] then
+        updated.each do |gem|
+          LibGems::DocManager.new(gem, options[:rdoc_args]).generate_rdoc
+        end
+      end
+    end
+  end
+
+  def update_gem name, version = LibGems::Requirement.default
+    return if @updated.any? { |spec| spec.name == name }
+    success = false
+
+    say "Updating #{name}"
+    begin
+      @installer.install name, version
+      success = true
+    rescue LibGems::InstallError => e
+      alert_error "Error installing #{name}:\n\t#{e.message}"
+      success = false
+    end
+
+    @installer.installed_gems.each do |spec|
+      @updated << spec
+      say "Successfully installed #{spec.full_name}" if success
+    end
+  end
+
+  def update_gems gems_to_update
+    gems_to_update.uniq.sort.each do |name|
+      update_gem name
+    end
+
+    @updated
+  end
+
+  def which_to_update(highest_installed_gems, gem_names)
+    result = []
+
+    highest_installed_gems.each do |l_name, l_spec|
+      next if not gem_names.empty? and
+              gem_names.all? { |name| /#{name}/ !~ l_spec.name }
+
+      dependency = LibGems::Dependency.new l_spec.name, "> #{l_spec.version}"
+
+      begin
+        fetcher = LibGems::SpecFetcher.fetcher
+        spec_tuples = fetcher.find_matching dependency
+      rescue LibGems::RemoteFetcher::FetchError => e
+        raise unless fetcher.warn_legacy e do
+          require 'libgems/source_info_cache'
+
+          dependency.name = '' if dependency.name == //
+
+          specs = LibGems::SourceInfoCache.search_with_source dependency
+
+          spec_tuples = specs.map do |spec, source_uri|
+            [[spec.name, spec.version, spec.original_platform], source_uri]
+          end
+        end
+      end
+
+      matching_gems = spec_tuples.select do |(name, _, platform),|
+        name == l_name and LibGems::Platform.match platform
+      end
+
+      highest_remote_gem = matching_gems.sort_by do |(_, version),|
+        version
+      end.last
+
+      if highest_remote_gem and
+         l_spec.version < highest_remote_gem.first[1] then
+        result << l_name
+      end
+    end
+
+    result
+  end
+
+end
+

data/lib/libgems/commands/which_command.rb

@@ -0,0 +1,86 @@
+require 'libgems/command'
+require 'libgems/gem_path_searcher'
+
+class LibGems::Commands::WhichCommand < LibGems::Command
+
+  EXT = %w[.rb .rbw .so .dll .bundle] # HACK
+
+  def initialize
+    super 'which', 'Find the location of a library file you can require',
+          :search_gems_first => false, :show_all => false
+
+    add_option '-a', '--[no-]all', 'show all matching files' do |show_all, options|
+      options[:show_all] = show_all
+    end
+
+    add_option '-g', '--[no-]gems-first',
+               'search gems before non-gems' do |gems_first, options|
+      options[:search_gems_first] = gems_first
+    end
+  end
+
+  def arguments # :nodoc:
+    "FILE          name of file to find"
+  end
+
+  def defaults_str # :nodoc:
+    "--no-gems-first --no-all"
+  end
+
+  def execute
+    searcher = LibGems::GemPathSearcher.new
+
+    found = false
+
+    options[:args].each do |arg|
+      arg = arg.sub(/#{Regexp.union(*EXT)}$/, '')
+      dirs = $LOAD_PATH
+      spec = searcher.find arg
+
+      if spec then
+        if options[:search_gems_first] then
+          dirs = gem_paths(spec) + $LOAD_PATH
+        else
+          dirs = $LOAD_PATH + gem_paths(spec)
+        end
+      end
+
+      paths = find_paths arg, dirs
+
+      if paths.empty? then
+        alert_error "Can't find ruby library file or shared library #{arg}"
+      else
+        say paths
+        found = true
+      end
+    end
+
+    terminate_interaction 1 unless found
+  end
+
+  def find_paths(package_name, dirs)
+    result = []
+
+    dirs.each do |dir|
+      EXT.each do |ext|
+        full_path = File.join dir, "#{package_name}#{ext}"
+        if File.exist? full_path then
+          result << full_path
+          return result unless options[:show_all]
+        end
+      end
+    end
+
+    result
+  end
+
+  def gem_paths(spec)
+    spec.require_paths.collect { |d| File.join spec.full_gem_path, d }
+  end
+
+  def usage # :nodoc:
+    "#{program_name} FILE [FILE ...]"
+  end
+
+end
+

data/lib/libgems/config_file.rb

@@ -0,0 +1,345 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+##
+# LibGems::ConfigFile SlimGems options and gem command options from ~/.gemrc.
+#
+# ~/.gemrc is a YAML file that uses strings to match gem command arguments and
+# symbols to match SlimGems options.
+#
+# LibGems command arguments use a String key that matches the command name and
+# allow you to specify default arguments:
+#
+#   install: --no-rdoc --no-ri
+#   update: --no-rdoc --no-ri
+#
+# You can use <tt>gem:</tt> to set default arguments for all commands.
+#
+# SlimGems options use symbol keys.  Valid options are:
+#
+# +:backtrace+:: See #backtrace
+# +:benchmark+:: See #benchmark
+# +:sources+:: Sets LibGems::sources
+# +:verbose+:: See #verbose
+
+class LibGems::ConfigFile
+
+  DEFAULT_BACKTRACE = false
+  DEFAULT_BENCHMARK = false
+  DEFAULT_BULK_THRESHOLD = 1000
+  DEFAULT_VERBOSITY = true
+  DEFAULT_UPDATE_SOURCES = true
+
+  ##
+  # For Ruby packagers to set configuration defaults.  Set in
+  # rubygems/defaults/operating_system.rb
+
+  OPERATING_SYSTEM_DEFAULTS = {}
+
+  ##
+  # For Ruby implementers to set configuration defaults.  Set in
+  # rubygems/defaults/#{RUBY_ENGINE}.rb
+
+  PLATFORM_DEFAULTS = {}
+
+  system_config_path =
+    begin
+      require 'Win32API'
+
+      CSIDL_COMMON_APPDATA = 0x0023
+      path = 0.chr * 260
+      if RUBY_VERSION > '1.9' then
+        SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'PLPLP',
+                                       'L', :stdcall
+        SHGetFolderPath.call nil, CSIDL_COMMON_APPDATA, nil, 1, path
+      else
+        SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'LLLLP',
+                                       'L'
+        SHGetFolderPath.call 0, CSIDL_COMMON_APPDATA, 0, 1, path
+      end
+
+      path.strip
+    rescue LoadError
+      '/etc'
+    end
+
+  SYSTEM_WIDE_CONFIG_FILE = File.join system_config_path, 'gemrc'
+
+  ##
+  # List of arguments supplied to the config file object.
+
+  attr_reader :args
+
+  ##
+  # Where to look for gems (deprecated)
+
+  attr_accessor :path
+
+  ##
+  # Where to install gems (deprecated)
+
+  attr_accessor :home
+
+  ##
+  # True if we print backtraces on errors.
+
+  attr_writer :backtrace
+
+  ##
+  # True if we are benchmarking this run.
+
+  attr_accessor :benchmark
+
+  ##
+  # Bulk threshold value.  If the number of missing gems are above this
+  # threshold value, then a bulk download technique is used.  (deprecated)
+
+  attr_accessor :bulk_threshold
+
+  ##
+  # Verbose level of output:
+  # * false -- No output
+  # * true -- Normal output
+  # * :loud -- Extra output
+
+  attr_accessor :verbose
+
+  ##
+  # True if we want to update the SourceInfoCache every time, false otherwise
+
+  attr_accessor :update_sources
+
+  ##
+  # API key for SlimGems.org
+
+  attr_reader :rubygems_api_key
+
+  ##
+  # Create the config file object.  +args+ is the list of arguments
+  # from the command line.
+  #
+  # The following command line options are handled early here rather
+  # than later at the time most command options are processed.
+  #
+  # <tt>--config-file</tt>, <tt>--config-file==NAME</tt>::
+  #   Obviously these need to be handled by the ConfigFile object to ensure we
+  #   get the right config file.
+  #
+  # <tt>--backtrace</tt>::
+  #   Backtrace needs to be turned on early so that errors before normal
+  #   option parsing can be properly handled.
+  #
+  # <tt>--debug</tt>::
+  #   Enable Ruby level debug messages.  Handled early for the same reason as
+  #   --backtrace.
+
+  def initialize(arg_list)
+    @config_file_name = nil
+    need_config_file_name = false
+
+    arg_list = arg_list.map do |arg|
+      if need_config_file_name then
+        @config_file_name = arg
+        need_config_file_name = false
+        nil
+      elsif arg =~ /^--config-file=(.*)/ then
+        @config_file_name = $1
+        nil
+      elsif arg =~ /^--config-file$/ then
+        need_config_file_name = true
+        nil
+      else
+        arg
+      end
+    end.compact
+
+    @backtrace = DEFAULT_BACKTRACE
+    @benchmark = DEFAULT_BENCHMARK
+    @bulk_threshold = DEFAULT_BULK_THRESHOLD
+    @verbose = DEFAULT_VERBOSITY
+    @update_sources = DEFAULT_UPDATE_SOURCES
+
+    operating_system_config = Marshal.load Marshal.dump(OPERATING_SYSTEM_DEFAULTS)
+    platform_config = Marshal.load Marshal.dump(PLATFORM_DEFAULTS)
+    system_config = load_file SYSTEM_WIDE_CONFIG_FILE
+    user_config = load_file config_file_name.dup.untaint
+
+    @hash = operating_system_config.merge platform_config
+    @hash = @hash.merge system_config
+    @hash = @hash.merge user_config
+
+    # HACK these override command-line args, which is bad
+    @backtrace        = @hash[:backtrace]        if @hash.key? :backtrace
+    @benchmark        = @hash[:benchmark]        if @hash.key? :benchmark
+    @bulk_threshold   = @hash[:bulk_threshold]   if @hash.key? :bulk_threshold
+    @home             = @hash[:gemhome]          if @hash.key? :gemhome
+    @path             = @hash[:gempath]          if @hash.key? :gempath
+    @update_sources   = @hash[:update_sources]   if @hash.key? :update_sources
+    @verbose          = @hash[:verbose]          if @hash.key? :verbose
+
+    load_rubygems_api_key
+
+    LibGems.sources = @hash[:sources] if @hash.key? :sources
+    handle_arguments arg_list
+  end
+
+  ##
+  # Location of SlimGems.org credentials
+
+  def credentials_path
+    File.join(LibGems.user_home, '.gem', 'credentials')
+  end
+
+  def load_rubygems_api_key
+    api_key_hash = File.exists?(credentials_path) ? load_file(credentials_path) : @hash
+
+    @rubygems_api_key = api_key_hash[:rubygems_api_key] if api_key_hash.key? :rubygems_api_key
+  end
+
+  def rubygems_api_key=(api_key)
+    config = load_file(credentials_path).merge(:rubygems_api_key => api_key)
+
+    dirname = File.dirname(credentials_path)
+    Dir.mkdir(dirname) unless File.exists?(dirname)
+
+    LibGems.load_yaml
+
+    File.open(credentials_path, 'w') do |f|
+      f.write config.to_yaml
+    end
+
+    @rubygems_api_key = api_key
+  end
+
+  def load_file(filename)
+    require "yaml"
+    return {} unless filename and File.exists?(filename)
+    begin
+      YAML.load(File.read(filename))
+    rescue ArgumentError
+      warn "Failed to load #{config_file_name}"
+    rescue Errno::EACCES
+      warn "Failed to load #{config_file_name} due to permissions problem."
+    end or {}
+  end
+
+  # True if the backtrace option has been specified, or debug is on.
+  def backtrace
+    @backtrace or $DEBUG
+  end
+
+  # The name of the configuration file.
+  def config_file_name
+    @config_file_name || LibGems.config_file
+  end
+
+  # Delegates to @hash
+  def each(&block)
+    hash = @hash.dup
+    hash.delete :update_sources
+    hash.delete :verbose
+    hash.delete :benchmark
+    hash.delete :backtrace
+    hash.delete :bulk_threshold
+
+    yield :update_sources, @update_sources
+    yield :verbose, @verbose
+    yield :benchmark, @benchmark
+    yield :backtrace, @backtrace
+    yield :bulk_threshold, @bulk_threshold
+
+    yield 'config_file_name', @config_file_name if @config_file_name
+
+    hash.each(&block)
+  end
+
+  # Handle the command arguments.
+  def handle_arguments(arg_list)
+    @args = []
+
+    arg_list.each do |arg|
+      case arg
+      when /^--(backtrace|traceback)$/ then
+        @backtrace = true
+      when /^--bench(mark)?$/ then
+        @benchmark = true
+      when /^--debug$/ then
+        $DEBUG = true
+      else
+        @args << arg
+      end
+    end
+  end
+
+  # Really verbose mode gives you extra output.
+  def really_verbose
+    case verbose
+    when true, false, nil then false
+    else true
+    end
+  end
+
+  # to_yaml only overwrites things you can't override on the command line.
+  def to_yaml # :nodoc:
+    yaml_hash = {}
+    yaml_hash[:backtrace] = @hash.key?(:backtrace) ? @hash[:backtrace] :
+      DEFAULT_BACKTRACE
+    yaml_hash[:benchmark] = @hash.key?(:benchmark) ? @hash[:benchmark] :
+      DEFAULT_BENCHMARK
+    yaml_hash[:bulk_threshold] = @hash.key?(:bulk_threshold) ?
+      @hash[:bulk_threshold] : DEFAULT_BULK_THRESHOLD
+    yaml_hash[:sources] = LibGems.sources
+    yaml_hash[:update_sources] = @hash.key?(:update_sources) ?
+      @hash[:update_sources] : DEFAULT_UPDATE_SOURCES
+    yaml_hash[:verbose] = @hash.key?(:verbose) ? @hash[:verbose] :
+      DEFAULT_VERBOSITY
+
+    keys = yaml_hash.keys.map { |key| key.to_s }
+    keys << 'debug'
+    re = Regexp.union(*keys)
+
+    @hash.each do |key, value|
+      key = key.to_s
+      next if key =~ re
+      yaml_hash[key.to_s] = value
+    end
+
+    yaml_hash.to_yaml
+  end
+
+  # Writes out this config file, replacing its source.
+  def write
+    open config_file_name, 'w' do |io|
+      io.write to_yaml
+    end
+  end
+
+  # Return the configuration information for +key+.
+  def [](key)
+    @hash[key.to_s]
+  end
+
+  # Set configuration option +key+ to +value+.
+  def []=(key, value)
+    @hash[key.to_s] = value
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other and
+    @backtrace == other.backtrace and
+    @benchmark == other.benchmark and
+    @bulk_threshold == other.bulk_threshold and
+    @verbose == other.verbose and
+    @update_sources == other.update_sources and
+    @hash == other.hash
+  end
+
+  protected
+
+  attr_reader :hash
+
+end
+