class RPM::Package

Public Class Methods

create(name, version) click to toggle source
# File lib/rpm/package.rb, line 19
def self.create(name, version)
  if not name.is_a?(String)
    raise TypeError, "illegal argument type: name should be String"
  end
  if not version.is_a?(RPM::Version)
    raise TypeError, "illegal argument type: version should be RPM::Version"
  end
  hdr = RPM::C.headerNew
  if RPM::C.headerPutString(hdr, :name, name) != 1
    raise "Can't set package name: #{name}"
  end
  if RPM::C.headerPutString(hdr, :version, version.v) != 1
    raise "Can't set package version: #{version.v}"
  end
  if version.e
    if RPM::C.headerPutUint32(hdr, :epoch, version.e) != 1
      raise "Can't set package epoch: #{version.e}"
    end
  end
  Package.new(hdr)
end
new(what) click to toggle source

@visibility private

# File lib/rpm/package.rb, line 301
def initialize(what)
  case what
    when String then initialize_from_filename(what)
    else initialize_from_header(what)
  end
end
open(filename) click to toggle source
# File lib/rpm/package.rb, line 286
def self.open(filename)
  Package.new(filename)
end
release(ptr) click to toggle source

@visibility private

# File lib/rpm/package.rb, line 291
def self.release(ptr)
  RPM::C.headerFree(ptr)
end
release_td(ptr) click to toggle source

@visibility private

# File lib/rpm/package.rb, line 296
def self.release_td(ptr)
  RPM::C.rpmtdFree(ptr)
end

Public Instance Methods

[](tag) click to toggle source

Access a header entry @param [Number] tag Tag to return @return [] Value of the entry @example

  pkg => #<RPM::Package name="xmlgraphics-fop", version=#<RPM::Version v="1.0", r="22.4">>
  pkg[:name] => "xmlgraphics-fop"

or if you have the old ruby-rpm compat loaded

  require 'rpm/compat'
  pkg[RPM::TAG_NAME] => "xmlgraphics-fop"

@return [String, Fixnum, Array<String>, Array<Fixnum>, nil]

The value of the entry
# File lib/rpm/package.rb, line 223
def [](tag)
  val = nil
  tagc = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))

  return nil if (RPM::C.headerGet(ptr, tag, tagc, 
                  RPM::C::HEADERGET_MINMEM) == 0)

  type = RPM::C.rpmtdType(tagc)
  count = RPM::C.rpmtdCount(tagc)
  ret_type = RPM::C.rpmTagGetReturnType(tag)

  method_name = case type
    when :int8_type, :char_type, :int16_type, :int32_type, :int64_type then :rpmtdGetNumber
    when :string_type, :string_array_type, :bin_type then :rpmtdGetString
    else raise NotImplementedError, "Don't know how to retrieve type '#{type}'"
  end

  is_array = case
    when count > 1 then true
    when ret_type == :array_return_type then true
    when type == :string_array_type then true
    else false
  end

  if is_array
    ret = []
    RPM::C.rpmtdInit(tagc)
    while RPM::C.rpmtdNext(tagc) != -1
      ret << RPM::C.send(method_name, tagc)
    end
    return ret
  end
  
  return RPM::C.send(method_name, tagc)
end
add_binary(tag, val) click to toggle source

Add a binary value to the package header @param [Number] tag Tag @param [String] val Value

# File lib/rpm/package.rb, line 75
def add_binary(tag, val)
  raise NotImplementedError
end
add_dependency(dep) click to toggle source

Add a dependency to the package header @param [Dependency] dep Dependency to add

# File lib/rpm/package.rb, line 43
def add_dependency(dep)
  unless dep.is_a?(Dependency)
    raise TypeError.new("illegal argument type: must be a Dependency")
  end

  raise NotImplementedError
end
add_int32(tag, val) click to toggle source

Add a int32 value to the package header @param [Number] tag Tag @param [Number] val Value

# File lib/rpm/package.rb, line 54
def add_int32(tag, val)
  raise NotImplementedError
end
add_string(tag, val) click to toggle source

Add a binary value to the package header @param [Number] tag Tag @param [String] val String to add

# File lib/rpm/package.rb, line 68
def add_string(tag, val)
  raise NotImplementedError
end
add_string_array(tag, val) click to toggle source

Add a list of strings to the package header @param [Number] tag Tag @param [Array<String>] val Strings to add

# File lib/rpm/package.rb, line 61
def add_string_array(tag, val)
  raise NotImplementedError
end
arch() click to toggle source

@return [String] This package architecture

# File lib/rpm/package.rb, line 265
def arch
  self[:arch]
end
changelog() click to toggle source

@return [Array<RPM::Changelog>] changelog of the package as an array

# File lib/rpm/package.rb, line 187
def changelog
  entries = []
  nametd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
  timetd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
  texttd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))

  min = RPM::C::HEADERGET_MINMEM
  return deps if (RPM::C.headerGet(@hdr, :changelogtime, timetd, min) != 1)
  return deps if (RPM::C.headerGet(@hdr, :changelogname, nametd, min) != 1)
  return deps if (RPM::C.headerGet(@hdr, :changelogtext, texttd, min) != 1)

  RPM::C.rpmtdInit(timetd)
  while RPM::C.rpmtdNext(timetd) != -1
    entry = RPM::ChangeLog.new
    entry.time = RPM::C.rpmtdGetUint32(timetd)
    entry.name = RPM::C.rpmtdNextString(nametd)
    entry.text = RPM::C.rpmtdNextString(texttd)
    entries << entry
  end
  entries
end
conflicts() click to toggle source

@return [Array<RPM::Conflicts>] Conflicts list for this package

# File lib/rpm/package.rb, line 177
def conflicts
  dependencies(RPM::Conflict, :conflictname, :conflictversion, :conflictflags)
end
delete_tag(tag) click to toggle source

Deletes a tag of the package header @param [Number] tag Tag

# File lib/rpm/package.rb, line 81
def delete_tag(tag)
  raise NotImplementedError
end
dependencies(klass, nametag, versiontag, flagtag) click to toggle source

@return [Array<RPM::Dependency>] Dependencies for klass @example

dependencies(RPM::Provide, :providename, :provideversion, :provideflags)

@visibility private

# File lib/rpm/package.rb, line 145
def dependencies(klass, nametag, versiontag, flagtag)
  deps = []

  nametd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
  versiontd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))
  flagtd = ::FFI::AutoPointer.new(RPM::C.rpmtdNew, Package.method(:release_td))

  min = RPM::C::HEADERGET_MINMEM
  return deps if (RPM::C.headerGet(@hdr, nametag, nametd, min) != 1)
  return deps if (RPM::C.headerGet(@hdr, versiontag, versiontd, min) != 1)
  return deps if (RPM::C.headerGet(@hdr, flagtag, flagtd, min) != 1)

  RPM::C.rpmtdInit(nametd)
  while RPM::C.rpmtdNext(nametd) != -1
    deps << klass.new(RPM::C.rpmtdGetString(nametd),
              RPM::Version.new(RPM::C.rpmtdNextString(versiontd)),
              RPM::C.rpmtdNextUint32(flagtd).read_uint, self)
  end
  deps
end
files() click to toggle source

@return [Array<RPM::File>] File list for this package

# File lib/rpm/package.rb, line 101
def files
  basenames = self[:basenames]

  return [] if basenames.nil?

  dirnames = self[:dirnames]
  diridxs = self[:dirindexes]
  statelist = self[:filestates]
  flaglist = self[:fileflags]
  sizelist = self[:filesizes]
  modelist = self[:filemodes]
  mtimelist = self[:filemtimes]
  rdevlist = self[:filerdevs]
  linklist = self[:filelinktos]
  md5list = self[:filemd5s]
  ownerlist = self[:fileusername]
  grouplist = self[:filegroupname]

  ret = []

  basenames.each_with_index do |basename, i|

    file = RPM::File.new("#{dirnames[diridxs[i]]}#{basenames[i]}",
            md5list[i],
            linklist[i],
            sizelist[i],
            mtimelist[i],
            ownerlist[i],
            grouplist[i],
            rdevlist[i],
            modelist[i],
            flaglist.nil? ? RPM::C::FileAttrs[:none] : flaglist[i],
            statelist.nil? ? RPM::C::FileState[:normal] : statelist[i]
    )
    ret << file
  end
  ret
end
initialize_from_filename(filename) click to toggle source
# File lib/rpm/package.rb, line 321
def initialize_from_filename(filename)
  # it sucks not using the std File.open here
  hdr = ::FFI::MemoryPointer.new(:pointer)
  fd = nil
  begin
    fd = RPM::C.Fopen(filename, 'r')
    if RPM::C.Ferror(fd) != 0
      raise "#{filename} : #{RPM::C.Fstrerror(fd)}"
    end
    RPM.transaction do |ts|
      rc = RPM::C.rpmReadPackageFile(ts.ptr, fd, filename, hdr)
    end
  ensure
    RPM::C.Fclose(fd) unless fd.nil?
  end
  initialize_from_header(hdr.get_pointer(0))
end
initialize_from_header(hdr=nil) click to toggle source

@visibility private

# File lib/rpm/package.rb, line 309
def initialize_from_header(hdr=nil)
  if hdr.nil?
    @hdr = ::FFI::AutoPointer.new(RPM::C.headerNew, Header.method(:release))
  elsif hdr.is_a?(::FFI::Pointer)
    # ref
    hdr = RPM::C.headerLink(hdr)
    @hdr = ::FFI::AutoPointer.new(hdr, Package.method(:release))
  else
    raise "Can't initialize header with '#{hdr}'"
  end
end
load(data) click to toggle source

Create a new package object from data @param [String] str Header data @return [Package]

# File lib/rpm/package.rb, line 15
def load(data)
  raise NotImplementedError
end
name() click to toggle source

@return [String] This package name

# File lib/rpm/package.rb, line 260
def name
  self[:name]
end
obsoletes() click to toggle source

@return [Array<RPM::Obsolete>] Obsoletes list for this package

# File lib/rpm/package.rb, line 182
def obsoletes
  dependencies(RPM::Obsolete, :obsoletename, :obsoleteversion, :obsoleteflags)
end
provides() click to toggle source

@return [Array<RPM::Provide>] Provides list for this package

# File lib/rpm/package.rb, line 167
def provides
  dependencies(RPM::Provide, :providename, :provideversion, :provideflags)
end
ptr() click to toggle source

@return [RPM::C::Header] header pointer @visibility private

# File lib/rpm/package.rb, line 341
def ptr
  @hdr
end
requires() click to toggle source

@return [Array<RPM::Require>] Requires list for this package

# File lib/rpm/package.rb, line 172
def requires
  dependencies(RPM::Require, :requirename, :requireversion, :requireflags)
end
signature() click to toggle source

@return [Number] This package signature

# File lib/rpm/package.rb, line 96
def signature
  sprintf('%{sigmd5}')
end
sprintf(fmt) click to toggle source

@return a formated string @example

pkg.sprintf("%{name}") => "apache2"
# File lib/rpm/package.rb, line 88
def sprintf(fmt)
  error = ::FFI::MemoryPointer.new(:pointer, 1)
  val = RPM::C.headerFormat(@hdr, fmt, error)
  raise error.get_pointer(0).read_string if val.null?
  val.read_string
end
to_s() click to toggle source

String representation of the package: “name-version-release-arch” @return [String]

# File lib/rpm/package.rb, line 279
def to_s
  return "" if name.nil?
  return name if version.nil?
  return "#{name}-#{version}" if arch.nil?
  return "#{name}-#{version}-#{arch}"
end
version() click to toggle source

@return [Version] Version for this package

# File lib/rpm/package.rb, line 272
def version

  Version.new(self[:version], self[:release], self[:epoch])
end