libgems 0.0.1

data/lib/libgems/commands/list_command.rb

@@ -0,0 +1,35 @@
+require 'libgems/command'
+require 'libgems/commands/query_command'
+
+##
+# An alternate to LibGems::Commands::QueryCommand that searches for gems starting
+# with the the supplied argument.
+
+class LibGems::Commands::ListCommand < LibGems::Commands::QueryCommand
+
+  def initialize
+    super 'list', 'Display gems whose name starts with STRING'
+
+    remove_option('--name-matches')
+  end
+
+  def arguments # :nodoc:
+    "STRING        start of gem name to look for"
+  end
+
+  def defaults_str # :nodoc:
+    "--local --no-details"
+  end
+
+  def usage # :nodoc:
+    "#{program_name} [STRING]"
+  end
+
+  def execute
+    string = get_one_optional_argument || ''
+    options[:name] = /^#{string}/i
+    super
+  end
+
+end
+

data/lib/libgems/commands/lock_command.rb

@@ -0,0 +1,110 @@
+require 'libgems/command'
+
+class LibGems::Commands::LockCommand < LibGems::Command
+
+  def initialize
+    super 'lock', 'Generate a lockdown list of gems',
+          :strict => false
+
+    add_option '-s', '--[no-]strict',
+               'fail if unable to satisfy a dependency' do |strict, options|
+      options[:strict] = strict
+    end
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       name of gem to lock\nVERSION       version of gem to lock"
+  end
+
+  def defaults_str # :nodoc:
+    "--no-strict"
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The lock command will generate a list of +gem+ statements that will lock down
+the versions for the gem given in the command line.  It will specify exact
+versions in the requirements list to ensure that the gems loaded will always
+be consistent.  A full recursive search of all effected gems will be
+generated.
+
+Example:
+
+  gemlock rails-1.0.0 > lockdown.rb
+
+will produce in lockdown.rb:
+
+  require "libgems"
+  gem 'rails', '= 1.0.0'
+  gem 'rake', '= 0.7.0.1'
+  gem 'activesupport', '= 1.2.5'
+  gem 'activerecord', '= 1.13.2'
+  gem 'actionpack', '= 1.11.2'
+  gem 'actionmailer', '= 1.1.5'
+  gem 'actionwebservice', '= 1.0.0'
+
+Just load lockdown.rb from your application to ensure that the current
+versions are loaded.  Make sure that lockdown.rb is loaded *before* any
+other require statements.
+
+Notice that rails 1.0.0 only requires that rake 0.6.2 or better be used.
+Rake-0.7.0.1 is the most recent version installed that satisfies that, so we
+lock it down to the exact version.
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} GEMNAME-VERSION [GEMNAME-VERSION ...]"
+  end
+
+  def complain(message)
+    if options[:strict] then
+      raise LibGems::Exception, message
+    else
+      say "# #{message}"
+    end
+  end
+
+  def execute
+    say "require 'libgems'"
+
+    locked = {}
+
+    pending = options[:args]
+
+    until pending.empty? do
+      full_name = pending.shift
+
+      spec = LibGems::SourceIndex.load_specification spec_path(full_name)
+
+      if spec.nil? then
+        complain "Could not find gem #{full_name}, try using the full name"
+        next
+      end
+
+      say "gem '#{spec.name}', '= #{spec.version}'" unless locked[spec.name]
+      locked[spec.name] = true
+
+      spec.runtime_dependencies.each do |dep|
+        next if locked[dep.name]
+        candidates = LibGems.source_index.search dep
+
+        if candidates.empty? then
+          complain "Unable to satisfy '#{dep}' from currently installed gems"
+        else
+          pending << candidates.last.full_name
+        end
+      end
+    end
+  end
+
+  def spec_path(gem_full_name)
+    gemspecs = LibGems.path.map do |path|
+      File.join path, "specifications", "#{gem_full_name}.gemspec"
+    end
+
+    gemspecs.find { |gemspec| File.exist? gemspec }
+  end
+
+end
+

data/lib/libgems/commands/mirror_command.rb

@@ -0,0 +1,111 @@
+require 'yaml'
+require 'zlib'
+
+require 'libgems/command'
+require 'open-uri'
+
+class LibGems::Commands::MirrorCommand < LibGems::Command
+
+  def initialize
+    super 'mirror', 'Mirror a gem repository'
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The mirror command uses the ~/.gemmirrorrc config file to mirror remote gem
+repositories to a local path. The config file is a YAML document that looks
+like this:
+
+  ---
+  - from: http://gems.example.com # source repository URI
+    to: /path/to/mirror           # destination directory
+
+Multiple sources and destinations may be specified.
+    EOF
+  end
+
+  def execute
+    config_file = File.join LibGems.user_home, '.gemmirrorrc'
+
+    raise "Config file #{config_file} not found" unless File.exist? config_file
+
+    mirrors = YAML.load_file config_file
+
+    raise "Invalid config file #{config_file}" unless mirrors.respond_to? :each
+
+    mirrors.each do |mir|
+      raise "mirror missing 'from' field" unless mir.has_key? 'from'
+      raise "mirror missing 'to' field" unless mir.has_key? 'to'
+
+      get_from = mir['from']
+      save_to = File.expand_path mir['to']
+
+      raise "Directory not found: #{save_to}" unless File.exist? save_to
+      raise "Not a directory: #{save_to}" unless File.directory? save_to
+
+      gems_dir = File.join save_to, "gems"
+
+      if File.exist? gems_dir then
+        raise "Not a directory: #{gems_dir}" unless File.directory? gems_dir
+      else
+        Dir.mkdir gems_dir
+      end
+
+      source_index_data = ''
+
+      say "fetching: #{get_from}/Marshal.#{LibGems.marshal_version}.Z"
+
+      get_from = URI.parse get_from
+
+      if get_from.scheme.nil? then
+        get_from = get_from.to_s
+      elsif get_from.scheme == 'file' then
+        # check if specified URI contains a drive letter (file:/D:/Temp)
+        get_from = get_from.to_s
+        get_from = if get_from =~ /^file:.*[a-z]:/i then
+                     get_from[6..-1]
+                   else
+                     get_from[5..-1]
+                   end
+      end
+
+      open File.join(get_from.to_s, "Marshal.#{LibGems.marshal_version}.Z"), "rb" do |y|
+        source_index_data = Zlib::Inflate.inflate y.read
+        open File.join(save_to, "Marshal.#{LibGems.marshal_version}"), "wb" do |out|
+          out.write source_index_data
+        end
+      end
+
+      source_index = Marshal.load source_index_data
+
+      progress = ui.progress_reporter source_index.size,
+                                      "Fetching #{source_index.size} gems"
+      source_index.each do |fullname, gem|
+        gem_file = gem.file_name
+        gem_dest = File.join gems_dir, gem_file
+
+        unless File.exist? gem_dest then
+          begin
+            open "#{get_from}/gems/#{gem_file}", "rb" do |g|
+              contents = g.read
+              open gem_dest, "wb" do |out|
+                out.write contents
+              end
+            end
+          rescue
+            old_gf = gem_file
+            gem_file = gem_file.downcase
+            retry if old_gf != gem_file
+            alert_error $!
+          end
+        end
+
+        progress.updated gem_file
+      end
+
+      progress.done
+    end
+  end
+
+end
+

data/lib/libgems/commands/outdated_command.rb

@@ -0,0 +1,33 @@
+require 'libgems/command'
+require 'libgems/local_remote_options'
+require 'libgems/spec_fetcher'
+require 'libgems/version_option'
+
+class LibGems::Commands::OutdatedCommand < LibGems::Command
+
+  include LibGems::LocalRemoteOptions
+  include LibGems::VersionOption
+
+  def initialize
+    super 'outdated', 'Display all gems that need updates'
+
+    add_local_remote_options
+    add_platform_option
+  end
+
+  def execute
+    locals = LibGems::SourceIndex.from_installed_gems
+
+    locals.outdated.sort.each do |name|
+      local = locals.find_name(name).last
+
+      dep = LibGems::Dependency.new local.name, ">= #{local.version}"
+      remotes = LibGems::SpecFetcher.fetcher.fetch dep
+      remote = remotes.last.first
+
+      say "#{local.name} (#{local.version} < #{remote.version})"
+    end
+  end
+
+end
+

data/lib/libgems/commands/owner_command.rb

@@ -0,0 +1,75 @@
+require 'libgems/command'
+require 'libgems/local_remote_options'
+require 'libgems/gemcutter_utilities'
+
+class LibGems::Commands::OwnerCommand < LibGems::Command
+  include LibGems::LocalRemoteOptions
+  include LibGems::GemcutterUtilities
+
+  def description # :nodoc:
+    "Manage gem owners on rubygems.org."
+  end
+
+  def arguments # :nodoc:
+    "GEM       gem to manage owners for"
+  end
+
+  def initialize
+    super 'owner', description
+    add_proxy_option
+    defaults.merge! :add => [], :remove => []
+
+    add_option '-a', '--add EMAIL', 'Add an owner' do |value, options|
+      options[:add] << value
+    end
+
+    add_option '-r', '--remove EMAIL', 'Remove an owner' do |value, options|
+      options[:remove] << value
+    end
+  end
+
+  def execute
+    sign_in
+    name = get_one_gem_name
+
+    add_owners    name, options[:add]
+    remove_owners name, options[:remove]
+    show_owners   name
+  end
+
+  def show_owners name
+    response = rubygems_api_request :get, "api/v1/gems/#{name}/owners.yaml" do |request|
+      request.add_field "Authorization", LibGems.configuration.rubygems_api_key
+    end
+
+    with_response response do |resp|
+      owners = YAML.load resp.body
+
+      say "Owners for gem: #{name}"
+      owners.each do |owner|
+        say "- #{owner['email']}"
+      end
+    end
+  end
+
+  def add_owners name, owners
+    manage_owners :post, name, owners
+  end
+
+  def remove_owners name, owners
+    manage_owners :delete, name, owners
+  end
+
+  def manage_owners method, name, owners
+    owners.each do |owner|
+      response = rubygems_api_request method, "api/v1/gems/#{name}/owners" do |request|
+        request.set_form_data 'email' => owner
+        request.add_field "Authorization", LibGems.configuration.rubygems_api_key
+      end
+
+      with_response response
+    end
+  end
+
+end
+

data/lib/libgems/commands/pristine_command.rb

@@ -0,0 +1,93 @@
+require 'fileutils'
+require 'libgems/command'
+require 'libgems/format'
+require 'libgems/installer'
+require 'libgems/version_option'
+
+class LibGems::Commands::PristineCommand < LibGems::Command
+
+  include LibGems::VersionOption
+
+  def initialize
+    super 'pristine',
+          'Restores installed gems to pristine condition from files located in the gem cache',
+          :version => LibGems::Requirement.default
+
+    add_option('--all',
+               'Restore all installed gems to pristine',
+               'condition') do |value, options|
+      options[:all] = value
+    end
+
+    add_version_option('restore to', 'pristine condition')
+  end
+
+  def arguments # :nodoc:
+    "GEMNAME       gem to restore to pristine condition (unless --all)"
+  end
+
+  def defaults_str # :nodoc:
+    "--all"
+  end
+
+  def description # :nodoc:
+    <<-EOF
+The pristine command compares the installed gems with the contents of the
+cached gem and restores any files that don't match the cached gem's copy.
+
+If you have made modifications to your installed gems, the pristine command
+will revert them.  After all the gem's files have been checked all bin stubs
+for the gem are regenerated.
+
+If the cached gem cannot be found, you will need to use `gem install` to
+revert the gem.
+    EOF
+  end
+
+  def usage # :nodoc:
+    "#{program_name} [args]"
+  end
+
+  def execute
+    gem_name = nil
+
+    specs = if options[:all] then
+              LibGems::SourceIndex.from_installed_gems.map do |name, spec|
+                spec
+              end
+            else
+              gem_name = get_one_gem_name
+              LibGems::SourceIndex.from_installed_gems.find_name(gem_name,
+                                                          options[:version])
+            end
+
+    if specs.empty? then
+      raise LibGems::Exception,
+            "Failed to find gem #{gem_name} #{options[:version]}"
+    end
+
+    install_dir = LibGems.dir # TODO use installer option
+
+    raise LibGems::FilePermissionError.new(install_dir) unless
+      File.writable?(install_dir)
+
+    say "Restoring gem(s) to pristine condition..."
+
+    specs.each do |spec|
+      gem = Dir[File.join(LibGems.dir, 'cache', spec.file_name)].first
+
+      if gem.nil? then
+        alert_error "Cached gem for #{spec.full_name} not found, use `gem install` to restore"
+        next
+      end
+
+      # TODO use installer options
+      installer = LibGems::Installer.new gem, :wrappers => true, :force => true
+      installer.install
+
+      say "Restored #{spec.full_name}"
+    end
+  end
+
+end
+