libgems 0.0.1

data/lib/libgems/commands/contents_command.rb

@@ -0,0 +1,98 @@
+require 'libgems/command'
+require 'libgems/version_option'
+
+class LibGems::Commands::ContentsCommand < LibGems::Command
+
+  include LibGems::VersionOption
+
+  def initialize
+    super 'contents', 'Display the contents of the installed gems',
+          :specdirs => [], :lib_only => false, :prefix => true
+
+    add_version_option
+
+    add_option(      '--all',
+               "Contents for all gems") do |all, options|
+      options[:all] = all
+    end
+
+    add_option('-s', '--spec-dir a,b,c', Array,
+               "Search for gems under specific paths") do |spec_dirs, options|
+      options[:specdirs] = spec_dirs
+    end
+
+    add_option('-l', '--[no-]lib-only',
+               "Only return files in the LibGems's lib_dirs") do |lib_only, options|
+      options[:lib_only] = lib_only
+    end
+
+    add_option(      '--[no-]prefix',
+               "Don't include installed path prefix") do |prefix, options|
+      options[:prefix] = prefix
+    end
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to list contents for"
+  end
+
+  def defaults_str # :nodoc:
+    "--no-lib-only --prefix"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME [GEMNAME ...]"
+  end
+
+  def execute
+    version = options[:version] || LibGems::Requirement.default
+
+    spec_dirs = options[:specdirs].map do |i|
+      [i, File.join(i, "specifications")]
+    end.flatten
+
+    path_kind = if spec_dirs.empty? then
+                  spec_dirs = LibGems::SourceIndex.installed_spec_directories
+                  "default gem paths"
+                else
+                  "specified path"
+                end
+
+    si = LibGems::SourceIndex.from_gems_in(*spec_dirs)
+
+    gem_names = if options[:all] then
+                  si.map { |_, spec| spec.name }
+                else
+                  get_all_gem_names
+                end
+
+    gem_names.each do |name|
+      gem_spec = si.find_name(name, version).last
+
+      unless gem_spec then
+        say "Unable to find gem '#{name}' in #{path_kind}"
+
+        if LibGems.configuration.verbose then
+          say "\nDirectories searched:"
+          spec_dirs.each { |dir| say dir }
+        end
+
+        terminate_interaction 1 if gem_names.length == 1
+      end
+
+      files = options[:lib_only] ? gem_spec.lib_files : gem_spec.files
+
+      files.each do |f|
+        path = if options[:prefix] then
+                 File.join gem_spec.full_gem_path, f
+               else
+                 f
+               end
+
+        say path
+      end
+    end
+  end
+
+end
+

data/lib/libgems/commands/dependency_command.rb

@@ -0,0 +1,195 @@
+require 'libgems/command'
+require 'libgems/local_remote_options'
+require 'libgems/version_option'
+require 'libgems/source_info_cache'
+
+class LibGems::Commands::DependencyCommand < LibGems::Command
+
+  include LibGems::LocalRemoteOptions
+  include LibGems::VersionOption
+
+  def initialize
+    super 'dependency',
+          'Show the dependencies of an installed gem',
+          :version => LibGems::Requirement.default, :domain => :local
+
+    add_version_option
+    add_platform_option
+    add_prerelease_option
+
+    add_option('-R', '--[no-]reverse-dependencies',
+               'Include reverse dependencies in the output') do
+      |value, options|
+      options[:reverse_dependencies] = value
+    end
+
+    add_option('-p', '--pipe',
+               "Pipe Format (name --version ver)") do |value, options|
+      options[:pipe_format] = value
+    end
+
+    add_local_remote_options
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to show dependencies for"
+  end
+
+  def defaults_str # :nodoc:
+    "--local --version '#{LibGems::Requirement.default}' --no-reverse-dependencies"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME"
+  end
+
+  def execute
+    options[:args] << '' if options[:args].empty?
+    specs = {}
+
+    source_indexes = Hash.new do |h, source_uri|
+      h[source_uri] = LibGems::SourceIndex.new
+    end
+
+    pattern = if options[:args].length == 1 and
+                 options[:args].first =~ /\A\/(.*)\/(i)?\z/m then
+                flags = $2 ? Regexp::IGNORECASE : nil
+                Regexp.new $1, flags
+              else
+                /\A#{Regexp.union(*options[:args])}/
+              end
+
+    dependency = LibGems::Dependency.new pattern, options[:version]
+    dependency.prerelease = options[:prerelease]
+
+    if options[:reverse_dependencies] and remote? and not local? then
+      alert_error 'Only reverse dependencies for local gems are supported.'
+      terminate_interaction 1
+    end
+
+    if local? then
+      LibGems.source_index.search(dependency).each do |spec|
+        source_indexes[:local].add_spec spec
+      end
+    end
+
+    if remote? and not options[:reverse_dependencies] then
+      fetcher = LibGems::SpecFetcher.fetcher
+
+      begin
+        specs_and_sources = fetcher.find_matching(dependency, false, true,
+                                                  dependency.prerelease?)
+
+        specs_and_sources.each do |spec_tuple, source_uri|
+          spec = fetcher.fetch_spec spec_tuple, URI.parse(source_uri)
+
+          source_indexes[source_uri].add_spec spec
+        end
+      rescue LibGems::RemoteFetcher::FetchError => e
+        raise unless fetcher.warn_legacy e do
+          require 'libgems/source_info_cache'
+
+          specs = LibGems::SourceInfoCache.search_with_source dependency, false
+
+          specs.each do |spec, source_uri|
+            source_indexes[source_uri].add_spec spec
+          end
+        end
+      end
+    end
+
+    if source_indexes.empty? then
+      patterns = options[:args].join ','
+      say "No gems found matching #{patterns} (#{options[:version]})" if
+        LibGems.configuration.verbose
+
+      terminate_interaction 1
+    end
+
+    specs = {}
+
+    source_indexes.values.each do |source_index|
+      source_index.gems.each do |name, spec|
+        specs[spec.full_name] = [source_index, spec]
+      end
+    end
+
+    reverse = Hash.new { |h, k| h[k] = [] }
+
+    if options[:reverse_dependencies] then
+      specs.values.each do |_, spec|
+        reverse[spec.full_name] = find_reverse_dependencies spec
+      end
+    end
+
+    if options[:pipe_format] then
+      specs.values.sort_by { |_, spec| spec }.each do |_, spec|
+        unless spec.dependencies.empty?
+          spec.dependencies.sort_by { |dep| dep.name }.each do |dep|
+            say "#{dep.name} --version '#{dep.requirement}'"
+          end
+        end
+      end
+    else
+      response = ''
+
+      specs.values.sort_by { |_, spec| spec }.each do |_, spec|
+        response << print_dependencies(spec)
+        unless reverse[spec.full_name].empty? then
+          response << "  Used by\n"
+          reverse[spec.full_name].each do |sp, dep|
+            response << "    #{sp} (#{dep})\n"
+          end
+        end
+        response << "\n"
+      end
+
+      say response
+    end
+  end
+
+  def print_dependencies(spec, level = 0)
+    response = ''
+    response << '  ' * level + "Gem #{spec.full_name}\n"
+    unless spec.dependencies.empty? then
+      spec.dependencies.sort_by { |dep| dep.name }.each do |dep|
+        response << '  ' * level + "  #{dep}\n"
+      end
+    end
+    response
+  end
+
+  ##
+  # Returns an Array of [specification, dep] that are satisfied by +spec+.
+
+  def find_reverse_dependencies(spec)
+    result = []
+
+    LibGems.source_index.each do |name, sp|
+      sp.dependencies.each do |dep|
+        dep = LibGems::Dependency.new(*dep) unless LibGems::Dependency === dep
+
+        if spec.name == dep.name and
+           dep.requirement.satisfied_by?(spec.version) then
+          result << [sp.full_name, dep]
+        end
+      end
+    end
+
+    result
+  end
+
+  def find_gems(name, source_index)
+    specs = {}
+
+    spec_list = source_index.search name, options[:version]
+
+    spec_list.each do |spec|
+      specs[spec.full_name] = [source_index, spec]
+    end
+
+    specs
+  end
+
+end
+

data/lib/libgems/commands/environment_command.rb

@@ -0,0 +1,133 @@
+require 'libgems/command'
+
+class LibGems::Commands::EnvironmentCommand < LibGems::Command
+
+  def initialize
+    super 'environment', "Display information about the #{LibGems::NAME} environment"
+  end
+
+  def arguments # :nodoc:
+    args = <<-EOF
+          packageversion  display the package version
+          gemdir          display the path where gems are installed
+          gempath         display path used to search for gems
+          version         display the gem format version
+          remotesources   display the remote gem servers
+          platform        display the supported gem platforms
+          <omitted>       display everything
+    EOF
+    return args.gsub(/^\s+/, '')
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The #{LibGems::NAME} environment can be controlled through command line arguments,
+gemrc files, environment variables and built-in defaults.
+
+Command line argument defaults and some #{LibGems::NAME} defaults can be set in
+~/.gemrc file for individual users and a /etc/gemrc for all users.  A gemrc
+is a YAML file with the following YAML keys:
+
+  :sources: A YAML array of remote gem repositories to install gems from
+  :verbose: Verbosity of the gem command.  false, true, and :really are the
+            levels
+  :update_sources: Enable/disable automatic updating of repository metadata
+  :backtrace: Print backtrace when #{LibGems::NAME} encounters an error
+  :bulk_threshold: Switch to a bulk update when this many sources are out of
+                   date (legacy setting)
+  :gempath: The paths in which to look for gems
+  gem_command: A string containing arguments for the specified gem command
+
+Example:
+
+  :verbose: false
+  install: --no-wrappers
+  update: --no-wrappers
+
+#{LibGems::NAME}' default local repository can be overriden with the GEM_PATH and
+GEM_HOME environment variables.  GEM_HOME sets the default repository to
+install into.  GEM_PATH allows multiple local repositories to be searched for
+gems.
+
+If you are behind a proxy server, #{LibGems::NAME} uses the HTTP_PROXY,
+HTTP_PROXY_USER and HTTP_PROXY_PASS environment variables to discover the
+proxy server.
+
+If you are packaging #{LibGems::NAME} all of #{LibGems::NAME}' defaults are in
+lib/libgems/defaults.rb.  You may override these in
+lib/libgems/defaults/operating_system.rb
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} [arg]"
+  end
+
+  def execute
+    out = ''
+    arg = options[:args][0]
+    case arg
+    when /^packageversion/ then
+      out << LibGems::RubyGemsPackageVersion
+    when /^version/ then
+      out << LibGems::VERSION
+    when /^gemdir/, /^gemhome/, /^home/, /^LIBGEMS_HOME/, /^GEM_HOME/ then
+      out << LibGems.dir
+    when /^gempath/, /^path/, /^LIBGEMS_PATH/, /^GEM_PATH/ then
+      out << LibGems.path.join(File::PATH_SEPARATOR)
+    when /^remotesources/ then
+      out << LibGems.sources.join("\n")
+    when /^platform/ then
+      out << LibGems.platforms.join(File::PATH_SEPARATOR)
+    when nil then
+      out = "#{LibGems::NAME} Environment:\n"
+
+      out << "  - LibGems VERSION: #{LibGems::VERSION}\n"
+      out << "  - RUBYGEMS VERSION: #{LibGems::GEM_VERSION}\n"
+
+      out << "  - RUBY VERSION: #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}"
+      out << " patchlevel #{RUBY_PATCHLEVEL}" if defined? RUBY_PATCHLEVEL
+      out << ") [#{RUBY_PLATFORM}]\n"
+
+      out << "  - INSTALLATION DIRECTORY: #{LibGems.dir}\n"
+
+      out << "  - RUBYGEMS PREFIX: #{LibGems.prefix}\n" unless LibGems.prefix.nil?
+
+      out << "  - RUBY EXECUTABLE: #{LibGems.ruby}\n"
+
+      out << "  - EXECUTABLE DIRECTORY: #{LibGems.bindir}\n"
+
+      out << "  - RUBYGEMS PLATFORMS:\n"
+      LibGems.platforms.each do |platform|
+        out << "    - #{platform}\n"
+      end
+
+      out << "  - GEM PATHS:\n"
+      out << "     - #{LibGems.dir}\n"
+
+      path = LibGems.path.dup
+      path.delete LibGems.dir
+      path.each do |p|
+        out << "     - #{p}\n"
+      end
+
+      out << "  - GEM CONFIGURATION:\n"
+      LibGems.configuration.each do |name, value|
+        value = value.gsub(/./, '*') if name == 'gemcutter_key'
+        out << "     - #{name.inspect} => #{value.inspect}\n"
+      end
+
+      out << "  - REMOTE SOURCES:\n"
+      LibGems.sources.each do |s|
+        out << "     - #{s}\n"
+      end
+
+    else
+      raise LibGems::CommandLineError, "Unknown enviroment option [#{arg}]"
+    end
+    say out
+    true
+  end
+
+end
+

data/lib/libgems/commands/fetch_command.rb

@@ -0,0 +1,67 @@
+require 'libgems/command'
+require 'libgems/local_remote_options'
+require 'libgems/version_option'
+require 'libgems/source_info_cache'
+
+class LibGems::Commands::FetchCommand < LibGems::Command
+
+  include LibGems::LocalRemoteOptions
+  include LibGems::VersionOption
+
+  def initialize
+    super 'fetch', 'Download a gem and place it in the current directory'
+
+    add_bulk_threshold_option
+    add_proxy_option
+    add_source_option
+
+    add_version_option
+    add_platform_option
+    add_prerelease_option
+  end
+
+  def arguments # :nodoc:
+    'GEMNAME       name of gem to download'
+  end
+
+  def defaults_str # :nodoc:
+    "--version '#{LibGems::Requirement.default}'"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME [GEMNAME ...]"
+  end
+
+  def execute
+    version = options[:version] || LibGems::Requirement.default
+    all = LibGems::Requirement.default != version
+
+    gem_names = get_all_gem_names
+
+    gem_names.each do |gem_name|
+      dep = LibGems::Dependency.new gem_name, version
+      dep.prerelease = options[:prerelease]
+
+      specs_and_sources = LibGems::SpecFetcher.fetcher.fetch(dep, all, true,
+                                                         dep.prerelease?)
+
+      specs_and_sources, errors =
+        LibGems::SpecFetcher.fetcher.fetch_with_errors(dep, all, true,
+                                                   dep.prerelease?)
+
+      spec, source_uri = specs_and_sources.sort_by { |s,| s.version }.last
+
+      if spec.nil? then
+        show_lookup_failure gem_name, version, errors, options[:domain]
+        next
+      end
+
+      path = LibGems::RemoteFetcher.fetcher.download spec, source_uri
+      FileUtils.mv path, spec.file_name
+
+      say "Downloaded #{spec.full_name}"
+    end
+  end
+
+end
+