libgems 0.0.1

data/lib/libgems/local_remote_options.rb

@@ -0,0 +1,135 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'uri'
+require 'libgems'
+
+##
+# Mixin methods for local and remote LibGems::Command options.
+
+module LibGems::LocalRemoteOptions
+
+  ##
+  # Allows OptionParser to handle HTTP URIs.
+
+  def accept_uri_http
+    OptionParser.accept URI::HTTP do |value|
+      begin
+        uri = URI.parse value
+      rescue URI::InvalidURIError
+        raise OptionParser::InvalidArgument, value
+      end
+
+      unless ['http', 'https', 'file'].include?(uri.scheme)
+         raise OptionParser::InvalidArgument, value
+      end
+
+      value
+    end
+  end
+
+  ##
+  # Add local/remote options to the command line parser.
+
+  def add_local_remote_options
+    add_option(:"Local/Remote", '-l', '--local',
+               'Restrict operations to the LOCAL domain') do |value, options|
+      options[:domain] = :local
+    end
+
+    add_option(:"Local/Remote", '-r', '--remote',
+      'Restrict operations to the REMOTE domain') do |value, options|
+      options[:domain] = :remote
+    end
+
+    add_option(:"Local/Remote", '-b', '--both',
+               'Allow LOCAL and REMOTE operations') do |value, options|
+      options[:domain] = :both
+    end
+
+    add_bulk_threshold_option
+    add_source_option
+    add_proxy_option
+    add_update_sources_option
+  end
+
+  ##
+  # Add the --bulk-threshold option
+
+  def add_bulk_threshold_option
+    add_option(:"Local/Remote", '-B', '--bulk-threshold COUNT',
+               "Threshold for switching to bulk",
+               "synchronization (default #{LibGems.configuration.bulk_threshold})") do
+      |value, options|
+      LibGems.configuration.bulk_threshold = value.to_i
+    end
+  end
+
+  ##
+  # Add the --http-proxy option
+
+  def add_proxy_option
+    accept_uri_http
+
+    add_option(:"Local/Remote", '-p', '--[no-]http-proxy [URL]', URI::HTTP,
+               'Use HTTP proxy for remote operations') do |value, options|
+      options[:http_proxy] = (value == false) ? :no_proxy : value
+      LibGems.configuration[:http_proxy] = options[:http_proxy]
+    end
+  end
+
+  ##
+  # Add the --source option
+
+  def add_source_option
+    accept_uri_http
+
+    add_option(:"Local/Remote", '--source URL', URI::HTTP,
+               'Use URL as the remote source for gems') do |source, options|
+      source << '/' if source !~ /\/\z/
+
+      if options[:added_source] then
+        LibGems.sources << source unless LibGems.sources.include?(source)
+      else
+        options[:added_source] = true
+        LibGems.sources.replace [source]
+      end
+    end
+  end
+
+  ##
+  # Add the --update-sources option
+
+  def add_update_sources_option
+    add_option(:"Local/Remote", '-u', '--[no-]update-sources',
+               'Update local source cache') do |value, options|
+      LibGems.configuration.update_sources = value
+    end
+  end
+
+  ##
+  # Is fetching of local and remote information enabled?
+
+  def both?
+    options[:domain] == :both
+  end
+
+  ##
+  # Is local fetching enabled?
+
+  def local?
+    options[:domain] == :local || options[:domain] == :both
+  end
+
+  ##
+  # Is remote fetching enabled?
+
+  def remote?
+    options[:domain] == :remote || options[:domain] == :both
+  end
+
+end
+

data/lib/libgems/old_format.rb

@@ -0,0 +1,153 @@
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require 'libgems'
+
+##
+# The format class knows the guts of the RubyGem .gem file format and provides
+# the capability to read gem files
+
+class LibGems::OldFormat
+
+  attr_accessor :spec, :file_entries, :gem_path
+
+  ##
+  # Constructs an instance of a Format object, representing the gem's data
+  # structure.
+  #
+  # gem:: [String] The file name of the gem
+
+  def initialize(gem_path)
+    require 'fileutils'
+    require 'zlib'
+    LibGems.load_yaml
+
+    @gem_path = gem_path
+  end
+
+  ##
+  # Reads the named gem file and returns a Format object, representing the
+  # data from the gem file
+  #
+  # file_path:: [String] Path to the gem file
+
+  def self.from_file_by_path(file_path)
+    unless File.exist?(file_path)
+      raise LibGems::Exception, "Cannot load gem file [#{file_path}]"
+    end
+
+    File.open(file_path, 'rb') do |file|
+      from_io(file, file_path)
+    end
+  end
+
+  ##
+  # Reads a gem from an io stream and returns a Format object, representing
+  # the data from the gem file
+  #
+  # io:: [IO] Stream from which to read the gem
+
+  def self.from_io(io, gem_path="(io)")
+    format = self.new(gem_path)
+    skip_ruby(io)
+    format.spec = read_spec(io)
+    format.file_entries = []
+    read_files_from_gem(io) do |entry, file_data|
+      format.file_entries << [entry, file_data]
+    end
+    format
+  end
+
+  private
+
+  ##
+  # Skips the Ruby self-install header.  After calling this method, the
+  # IO index will be set after the Ruby code.
+  #
+  # file:: [IO] The IO to process (skip the Ruby code)
+
+  def self.skip_ruby(file)
+    end_seen = false
+    loop {
+      line = file.gets
+      if(line == nil || line.chomp == "__END__") then
+        end_seen = true
+        break
+      end
+    }
+
+    if end_seen == false then
+      raise LibGems::Exception.new("Failed to find end of ruby script while reading gem")
+    end
+  end
+
+  ##
+  # Reads the specification YAML from the supplied IO and constructs
+  # a LibGems::Specification from it.  After calling this method, the
+  # IO index will be set after the specification header.
+  #
+  # file:: [IO] The IO to process
+
+  def self.read_spec(file)
+    yaml = ''
+
+    read_until_dashes file do |line|
+      yaml << line
+    end
+
+    LibGems::Specification.from_yaml yaml
+  rescue YAML::Error => e
+    raise LibGems::Exception, "Failed to parse gem specification out of gem file"
+  rescue ArgumentError => e
+    raise LibGems::Exception, "Failed to parse gem specification out of gem file"
+  end
+
+  ##
+  # Reads lines from the supplied IO until a end-of-yaml (---) is
+  # reached
+  #
+  # file:: [IO] The IO to process
+  # block:: [String] The read line
+
+  def self.read_until_dashes(file)
+    while((line = file.gets) && line.chomp.strip != "---") do
+      yield line
+    end
+  end
+
+  ##
+  # Reads the embedded file data from a gem file, yielding an entry
+  # containing metadata about the file and the file contents themselves
+  # for each file that's archived in the gem.
+  # NOTE: Many of these methods should be extracted into some kind of
+  # LibGems file read/writer
+  #
+  # gem_file:: [IO] The IO to process
+
+  def self.read_files_from_gem(gem_file)
+    errstr = "Error reading files from gem"
+    header_yaml = ''
+    begin
+      self.read_until_dashes(gem_file) do |line|
+        header_yaml << line
+      end
+      header = YAML.load(header_yaml)
+      raise LibGems::Exception, errstr unless header
+
+      header.each do |entry|
+        file_data = ''
+        self.read_until_dashes(gem_file) do |line|
+          file_data << line
+        end
+        yield [entry, Zlib::Inflate.inflate(file_data.strip.unpack("m")[0])]
+      end
+    rescue Zlib::DataError
+      raise LibGems::Exception, errstr
+    end
+  end
+
+end
+

data/lib/libgems/package.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#--
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# See LICENSE.txt for additional licensing information.
+#++
+
+require 'fileutils'
+require 'find'
+require 'stringio'
+require 'yaml'
+require 'zlib'
+
+require 'libgems/security'
+require 'libgems/specification'
+
+##
+# Wrapper for FileUtils meant to provide logging and additional operations if
+# needed.
+
+class LibGems::FileOperations
+
+  def initialize(logger = nil)
+    @logger = logger
+  end
+
+  def method_missing(meth, *args, &block)
+    case
+    when FileUtils.respond_to?(meth)
+      @logger.log "#{meth}: #{args}" if @logger
+      FileUtils.send meth, *args, &block
+    when LibGems::FileOperations.respond_to?(meth)
+      @logger.log "#{meth}: #{args}" if @logger
+      LibGems::FileOperations.send meth, *args, &block
+    else
+      super
+    end
+  end
+
+end
+
+module LibGems::Package
+
+  class Error < StandardError; end
+  class NonSeekableIO < Error; end
+  class ClosedIO < Error; end
+  class BadCheckSum < Error; end
+  class TooLongFileName < Error; end
+  class FormatError < Error; end
+
+  def self.open(io, mode = "r", signer = nil, &block)
+    tar_type = case mode
+               when 'r' then TarInput
+               when 'w' then TarOutput
+               else
+                 raise "Unknown Package open mode"
+               end
+
+    tar_type.open(io, signer, &block)
+  end
+
+  def self.pack(src, destname, signer = nil)
+    TarOutput.open(destname, signer) do |outp|
+      dir_class.chdir(src) do
+        outp.metadata = (file_class.read("RPA/metadata") rescue nil)
+        find_class.find('.') do |entry|
+          case
+          when file_class.file?(entry)
+            entry.sub!(%r{\./}, "")
+            next if entry =~ /\ARPA\//
+            stat = File.stat(entry)
+            outp.add_file_simple(entry, stat.mode, stat.size) do |os|
+              file_class.open(entry, "rb") do |f|
+                os.write(f.read(4096)) until f.eof?
+              end
+            end
+          when file_class.dir?(entry)
+            entry.sub!(%r{\./}, "")
+            next if entry == "RPA"
+            outp.mkdir(entry, file_class.stat(entry).mode)
+          else
+            raise "Don't know how to pack this yet!"
+          end
+        end
+      end
+    end
+  end
+
+end
+
+require 'libgems/package/f_sync_dir'
+require 'libgems/package/tar_header'
+require 'libgems/package/tar_input'
+require 'libgems/package/tar_output'
+require 'libgems/package/tar_reader'
+require 'libgems/package/tar_reader/entry'
+require 'libgems/package/tar_writer'
+

data/lib/libgems/package/f_sync_dir.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+#--
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# See LICENSE.txt for additional licensing information.
+#++
+
+module LibGems::Package::FSyncDir
+
+  private
+
+  ##
+  # make sure this hits the disc
+
+  def fsync_dir(dirname)
+    dir = open dirname, 'r'
+    dir.fsync
+  rescue # ignore IOError if it's an unpatched (old) Ruby
+  ensure
+    dir.close if dir rescue nil
+  end
+
+end
+

data/lib/libgems/package/tar_header.rb

@@ -0,0 +1,266 @@
+# -*- coding: utf-8 -*-
+#--
+# Copyright (C) 2004 Mauricio Julio Fernández Pradier
+# See LICENSE.txt for additional licensing information.
+#++
+
+##
+#--
+# struct tarfile_entry_posix {
+#   char name[100];     # ASCII + (Z unless filled)
+#   char mode[8];       # 0 padded, octal, null
+#   char uid[8];        # ditto
+#   char gid[8];        # ditto
+#   char size[12];      # 0 padded, octal, null
+#   char mtime[12];     # 0 padded, octal, null
+#   char checksum[8];   # 0 padded, octal, null, space
+#   char typeflag[1];   # file: "0"  dir: "5"
+#   char linkname[100]; # ASCII + (Z unless filled)
+#   char magic[6];      # "ustar\0"
+#   char version[2];    # "00"
+#   char uname[32];     # ASCIIZ
+#   char gname[32];     # ASCIIZ
+#   char devmajor[8];   # 0 padded, octal, null
+#   char devminor[8];   # o padded, octal, null
+#   char prefix[155];   # ASCII + (Z unless filled)
+# };
+#++
+# A header for a tar file
+
+class LibGems::Package::TarHeader
+
+  ##
+  # Fields in the tar header
+
+  FIELDS = [
+    :checksum,
+    :devmajor,
+    :devminor,
+    :gid,
+    :gname,
+    :linkname,
+    :magic,
+    :mode,
+    :mtime,
+    :name,
+    :prefix,
+    :size,
+    :typeflag,
+    :uid,
+    :uname,
+    :version,
+  ]
+
+  ##
+  # Pack format for a tar header
+
+  PACK_FORMAT = 'a100' + # name
+                'a8'   + # mode
+                'a8'   + # uid
+                'a8'   + # gid
+                'a12'  + # size
+                'a12'  + # mtime
+                'a7a'  + # chksum
+                'a'    + # typeflag
+                'a100' + # linkname
+                'a6'   + # magic
+                'a2'   + # version
+                'a32'  + # uname
+                'a32'  + # gname
+                'a8'   + # devmajor
+                'a8'   + # devminor
+                'a155'   # prefix
+
+  ##
+  # Unpack format for a tar header
+
+  UNPACK_FORMAT = 'A100' + # name
+                  'A8'   + # mode
+                  'A8'   + # uid
+                  'A8'   + # gid
+                  'A12'  + # size
+                  'A12'  + # mtime
+                  'A8'   + # checksum
+                  'A'    + # typeflag
+                  'A100' + # linkname
+                  'A6'   + # magic
+                  'A2'   + # version
+                  'A32'  + # uname
+                  'A32'  + # gname
+                  'A8'   + # devmajor
+                  'A8'   + # devminor
+                  'A155'   # prefix
+
+  attr_reader(*FIELDS)
+
+  ##
+  # Creates a tar header from IO +stream+
+
+  def self.from(stream)
+    header = stream.read 512
+    empty = (header == "\0" * 512)
+
+    fields = header.unpack UNPACK_FORMAT
+
+    name     = fields.shift
+    mode     = fields.shift.oct
+    uid      = fields.shift.oct
+    gid      = fields.shift.oct
+    size     = fields.shift.oct
+    mtime    = fields.shift.oct
+    checksum = fields.shift.oct
+    typeflag = fields.shift
+    linkname = fields.shift
+    magic    = fields.shift
+    version  = fields.shift.oct
+    uname    = fields.shift
+    gname    = fields.shift
+    devmajor = fields.shift.oct
+    devminor = fields.shift.oct
+    prefix   = fields.shift
+
+    new :name     => name,
+        :mode     => mode,
+        :uid      => uid,
+        :gid      => gid,
+        :size     => size,
+        :mtime    => mtime,
+        :checksum => checksum,
+        :typeflag => typeflag,
+        :linkname => linkname,
+        :magic    => magic,
+        :version  => version,
+        :uname    => uname,
+        :gname    => gname,
+        :devmajor => devmajor,
+        :devminor => devminor,
+        :prefix   => prefix,
+
+        :empty    => empty
+
+    # HACK unfactor for Rubinius
+    #new :name     => fields.shift,
+    #    :mode     => fields.shift.oct,
+    #    :uid      => fields.shift.oct,
+    #    :gid      => fields.shift.oct,
+    #    :size     => fields.shift.oct,
+    #    :mtime    => fields.shift.oct,
+    #    :checksum => fields.shift.oct,
+    #    :typeflag => fields.shift,
+    #    :linkname => fields.shift,
+    #    :magic    => fields.shift,
+    #    :version  => fields.shift.oct,
+    #    :uname    => fields.shift,
+    #    :gname    => fields.shift,
+    #    :devmajor => fields.shift.oct,
+    #    :devminor => fields.shift.oct,
+    #    :prefix   => fields.shift,
+
+    #    :empty => empty
+  end
+
+  ##
+  # Creates a new TarHeader using +vals+
+
+  def initialize(vals)
+    unless vals[:name] && vals[:size] && vals[:prefix] && vals[:mode] then
+      raise ArgumentError, ":name, :size, :prefix and :mode required"
+    end
+
+    vals[:uid] ||= 0
+    vals[:gid] ||= 0
+    vals[:mtime] ||= 0
+    vals[:checksum] ||= ""
+    vals[:typeflag] ||= "0"
+    vals[:magic] ||= "ustar"
+    vals[:version] ||= "00"
+    vals[:uname] ||= "wheel"
+    vals[:gname] ||= "wheel"
+    vals[:devmajor] ||= 0
+    vals[:devminor] ||= 0
+
+    FIELDS.each do |name|
+      instance_variable_set "@#{name}", vals[name]
+    end
+
+    @empty = vals[:empty]
+  end
+
+  ##
+  # Is the tar entry empty?
+
+  def empty?
+    @empty
+  end
+
+  def ==(other) # :nodoc:
+    self.class === other and
+    @checksum == other.checksum and
+    @devmajor == other.devmajor and
+    @devminor == other.devminor and
+    @gid      == other.gid      and
+    @gname    == other.gname    and
+    @linkname == other.linkname and
+    @magic    == other.magic    and
+    @mode     == other.mode     and
+    @mtime    == other.mtime    and
+    @name     == other.name     and
+    @prefix   == other.prefix   and
+    @size     == other.size     and
+    @typeflag == other.typeflag and
+    @uid      == other.uid      and
+    @uname    == other.uname    and
+    @version  == other.version
+  end
+
+  def to_s # :nodoc:
+    update_checksum
+    header
+  end
+
+  ##
+  # Updates the TarHeader's checksum
+
+  def update_checksum
+    header = header " " * 8
+    @checksum = oct calculate_checksum(header), 6
+  end
+
+  private
+
+  def calculate_checksum(header)
+    header.unpack("C*").inject { |a, b| a + b }
+  end
+
+  def header(checksum = @checksum)
+    header = [
+      name,
+      oct(mode, 7),
+      oct(uid, 7),
+      oct(gid, 7),
+      oct(size, 11),
+      oct(mtime, 11),
+      checksum,
+      " ",
+      typeflag,
+      linkname,
+      magic,
+      oct(version, 2),
+      uname,
+      gname,
+      oct(devmajor, 7),
+      oct(devminor, 7),
+      prefix
+    ]
+
+    header = header.pack PACK_FORMAT
+
+    header << ("\0" * ((512 - header.size) % 512))
+  end
+
+  def oct(num, len)
+    "%0#{len}o" % num
+  end
+
+end
+