rpm 0.0.0 → 0.0.2

data/lib/rpm/ffi/rpmtypes.rb

@@ -0,0 +1,29 @@
+
+module RPM
+
+  module FFI
+
+  	Rc = enum(
+      :ok, 0,
+      :notfound, 1,
+      :fail, 2,
+      :nottrusted, 3,
+      :nokey, 4
+    )
+
+    typedef :int32, :rpm_tag_t
+    typedef :uint32, :rpm_tagtype_t;
+    typedef :uint32, :rpm_count_t
+    typedef :rpm_tag_t, :rpmTagVal;
+    typedef :rpm_tag_t, :rpmDbiTagVal
+
+    typedef :uint32, :rpmFlags
+
+    typedef :pointer, :FD_t
+    typedef :pointer, :fnpyKey
+    typedef :pointer, :rpmCallbackData
+
+    typedef :uint64, :rpm_loff_t
+
+  end
+end

data/lib/rpm/ffi.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'ffi'
+
+module RPM
+  module FFI
+
+    extend ::FFI::Library
+
+    begin
+      ffi_lib('rpm')
+    rescue LoadError => e
+      raise(
+        "Can't find rpm libs on your system: #{e.message}"
+      )
+    end
+
+  end
+end
+
+require 'rpm/ffi/rpmtypes'
+require 'rpm/ffi/rpmcallback'
+require 'rpm/ffi/rpmtag'
+require 'rpm/ffi/rpmlib'
+require 'rpm/ffi/rpmlog'
+require 'rpm/ffi/rpmmacro'
+require 'rpm/ffi/header'
+require 'rpm/ffi/rpmprob'
+require 'rpm/ffi/rpmps'
+require 'rpm/ffi/rpmfi'
+require 'rpm/ffi/rpmdb'
+require 'rpm/ffi/rpmts'
+require 'rpm/ffi/rpmds'
+require 'rpm/ffi/rpmtd'
+
+module RPM
+  module FFI
+
+    def self.rpm_version_code
+      ver = ::RPM::FFI.RPMVERSION.split('.', 3)
+      return (ver[0].to_i<<16) + (ver[1].to_i<<8) + (ver[2].to_i<<0)
+    end
+
+  end
+end

data/lib/rpm/file.rb

@@ -0,0 +1,132 @@
+
+module RPM
+
+  class File
+
+    # @return [String] file path
+    attr_accessor :path
+    # @return [String] md5sum as string
+    attr_accessor :md5sum
+    # @return [String] Path to the destination if the file is a symbolic link
+    # @note
+    #   This path is sometimes relative. To convert an absolute path from relative path:
+    #   File.expand_path (file.link_to, File.dirname (file.path))
+    attr_accessor :link_to
+    # @return [Number] File size
+    attr_accessor :size
+    # @return [Time] File modification time.
+    attr_accessor :mtime
+    # @return [String] File owner. Nil may be returned.
+    attr_accessor :owner
+    # @return [String] Group that owns the file. Nil may be returned.
+    attr_accessor :group
+    # @return [Number] Device type of the file
+    attr_accessor :mode
+
+    attr_accessor :attr
+    attr_accessor :state
+    attr_accessor :rdev
+
+    # @return [Boolean] True if the file is a symbolic link
+    def symlink?
+      ! @link_to.nil?
+    end
+
+    # @return [Boolean] True if the file is marked as a configuration file
+    def config?
+      ! (@attr & FileAttrs[:config]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as documentation
+    def doc?
+      ! (@attr & FileAttrs[:doc]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as do not use
+    def donotuse?
+      ! (@attr & FileAttrs[:donotuse]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked that can be missing on disk
+    #
+    # This modifier is used for files or links that are created during the %post scripts
+    # but will need to be removed if the package is removed
+    def is_missingok?
+      ! (@attr & FileAttrs[:missingok]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as configuration not to be replaced
+    #
+    # This flag is used to protect local modifications.
+    # If used, the file will not overwrite an existing file that has been modified.
+    # If the file has not been modified on disk, the rpm command will overwrite the file. But,
+    #   if the file has been modified on disk, the rpm command will copy the new file with an extra
+    #   file-name extension of .rpmnew.
+    def is_noreplace?
+      ! (@attr & FileAttrs[:noreplace]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as a spec file
+    def is_specfile?
+      ! (@attr & FileAttrs[:specfile]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as ghost
+    #
+    # This flag indicates the file should not be included in the package.
+    # It can be used to name the needed attributes for a file that the program, when installed,
+    #   will create.
+    # For example, you may want to ensure that a program’s log file has certain attributes.
+    def ghost?
+      ! (@attr & FileAttrs[:ghost]).zero?
+    end
+
+    # @return [Boolean] True if the file is a license
+    def license?
+      ! (@attr & FileAttrs[:license]).zero?
+    end
+
+    # @return [Boolean] True if the file is a README
+    def readme?
+      ! (@attr & FileAttrs[:readme]).zero?
+    end
+
+    # @return [Boolean] True if the file is listed in the exlude section
+    def exclude?
+      ! (@attr & FileAttrs[:exclude]).zero?
+    end
+
+    # @return [Boolean] True if the file is replaced during installation
+    def replaced?
+      ! (@attr & FileState[:replaced]).zero?
+    end
+
+    # @return [Boolean] True if the file is not installed
+    def notinstalled?
+      ! (@attr & FileState[:notinstalled]).zero?
+    end
+
+    # @return [Boolean] True if the file is shared over the network
+    def netshared?
+      ! (@attr & FileState[:netshared]).zero?
+    end
+
+    def initialize(path, md5sum, link_to, size, mtime, owner, group, rdev, mode, attr, state)
+      @path = path
+      @md5sum = md5sum
+      # If link_to is "" save it as nil
+      @link_to = ((link_to && link_to.empty?) ? nil : link_to)
+      @size = size
+      @mtime = mtime
+      @owner = owner
+      @group = group
+      @rdev = rdev
+      @mode = mode
+      @attr = attr
+      @state = state
+    end
+
+    
+  
+end
+end

data/lib/rpm/gem_version.rb

@@ -0,0 +1,7 @@
+
+# The reason this file is gem_version.rb and not version.rb
+# is because it conflicts with the version.rb class
+module RPM
+  PKG_NAME = "ruby-rpm"
+  GEM_VERSION = "0.0.2"
+end

data/lib/rpm/match_iterator.rb

@@ -0,0 +1,73 @@
+
+module RPM
+
+  class MatchIterator
+
+    include Enumerable
+
+    # @visibility private
+    def self.release(ptr)
+      RPM::FFI.rpmdbFreeIterator(ptr)
+    end
+
+    # Creates a managed MatchIterator from a raw pointer
+    # @visibility private
+    def self.from_ptr(ptr)
+      new(::FFI::AutoPointer.new(ptr, MatchIterator.method(:release)))
+    end
+
+    def initialize(ptr)
+      @ptr = ptr
+    end
+
+    def each
+      while (pkg = next_iterator)
+        yield pkg
+      end
+    end
+
+    def next_iterator
+      pkg_ptr = RPM::FFI.rpmdbNextIterator(@ptr)
+        if !pkg_ptr.null?
+          return RPM::Package.new(pkg_ptr)
+        end
+        return nil;
+    end
+
+    # @ return header join key for current position of rpm 
+    # database iterator
+    def offset
+      RPM::FFI.rpmdbGetIteratorOffset(@ptr)
+    end
+
+    def set_iterator_re(tag, mode, string)
+      ret = RPM::FFI.rpmdbSetIteratorRE(@ptr, tag, mode, string)
+      raise "Error when setting regular expression '#{string}'" if ret != 0
+      self
+    end
+
+    alias :regexp :set_iterator_re
+
+    def set_iterator_version(version)
+      if not version.is_a?(RPM::Version)
+        raise TypeError, 'illegal argument type'
+      end
+
+      set_iterator_re(:version, :default, version.v)
+      if (version.r)
+        set_iterator_re(:release, :default, version.r)
+      end
+      self
+    end
+
+    alias :version :set_iterator_version
+    
+    def get_iterator_count
+      RPM::FFI.rpmdbGetIteratorCount(@ptr)
+    end
+
+    alias :count :get_iterator_count
+    alias :length :get_iterator_count
+
+  end
+end

data/lib/rpm/package.rb

@@ -0,0 +1,344 @@
+require 'rpm/ffi'
+require 'rpm/file'
+
+module RPM
+
+  class ChangeLog
+    attr_accessor :time, :name, :text
+  end
+
+  class Package
+
+    # Create a new package object from data
+    # @param [String] str Header data
+    # @return [Package]
+    def load(data)
+      raise NotImplementedError
+    end
+
+    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::FFI.headerNew
+      if RPM::FFI.headerPutString(hdr, :name, name) != 1
+        raise "Can't set package name: #{name}"
+      end
+      if RPM::FFI.headerPutString(hdr, :version, version.v) != 1
+        raise "Can't set package version: #{version.v}"
+      end
+      if version.e
+        if RPM::FFI.headerPutUint32(hdr, :epoch, version.e) != 1
+          raise "Can't set package epoch: #{version.e}"
+        end
+      end
+      Package.new(hdr)
+    end
+
+    # Add a dependency to the package header
+    # @param [Dependency] dep Dependency to add
+    def add_dependency(dep)
+      unless dep.is_a?(Dependency)
+        raise TypeError.new("illegal argument type: must be a Dependency")
+      end
+
+      raise NotImplementedError
+    end
+
+    # Add a int32 value to the package header
+    # @param [Number] tag Tag
+    # @param [Number] val Value
+    def add_int32(tag, val)
+      raise NotImplementedError
+    end
+
+    # Add a list of strings to the package header
+    # @param [Number] tag Tag
+    # @param [Array<String>] val Strings to add
+    def add_string_array(tag, val)
+      raise NotImplementedError
+    end
+
+    # Add a binary value to the package header
+    # @param [Number] tag Tag
+    # @param [String] val String to add
+    def add_string(tag, val)
+      raise NotImplementedError
+    end
+
+    # Add a binary value to the package header
+    # @param [Number] tag Tag
+    # @param [String] val Value
+    def add_binary(tag, val)
+      raise NotImplementedError
+    end
+
+    # Deletes a tag of the package header
+    # @param [Number] tag Tag
+    def delete_tag(tag)
+      raise NotImplementedError
+    end
+
+    # @return a formated string
+    # @example
+    #   pkg.sprintf("%{name}") => "apache2"
+    def sprintf(fmt)
+      error = ::FFI::MemoryPointer.new(:pointer, 1)
+      val = RPM::FFI.headerFormat(@hdr, fmt, error)
+      raise error.get_pointer(0).read_string if val.null?
+      val.read_string
+    end
+
+    # @return [Number] This package signature
+    def signature
+      sprintf('%{sigmd5}')
+    end
+
+    # @return [Array<RPM::File>] File list for this package
+    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::FFI::FileAttrs[:none] : flaglist[i],
+                statelist.nil? ? RPM::FFI::FileState[:normal] : statelist[i]
+        )
+        ret << file
+      end
+      ret
+    end
+
+    # @return [Array<RPM::Dependency>] Dependencies for +klass+
+    # @example
+    #    dependencies(RPM::Provide, :providename, :provideversion, :provideflags)
+    #
+    # @visibility private
+    def dependencies(klass, nametag, versiontag, flagtag)
+      deps = []
+
+      nametd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+      versiontd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+      flagtd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+
+      min = RPM::FFI::HEADERGET_MINMEM
+      return deps if (RPM::FFI.headerGet(@hdr, nametag, nametd, min) != 1)
+      return deps if (RPM::FFI.headerGet(@hdr, versiontag, versiontd, min) != 1)
+      return deps if (RPM::FFI.headerGet(@hdr, flagtag, flagtd, min) != 1)
+
+      RPM::FFI.rpmtdInit(nametd)
+      while RPM::FFI.rpmtdNext(nametd) != -1
+        deps << klass.new(RPM::FFI.rpmtdGetString(nametd),
+                  RPM::Version.new(RPM::FFI.rpmtdNextString(versiontd)),
+                  RPM::FFI.rpmtdNextUint32(flagtd).read_uint, self)
+      end
+      deps
+    end
+
+    # @return [Array<RPM::Provide>] Provides list for this package
+    def provides
+      dependencies(RPM::Provide, :providename, :provideversion, :provideflags)
+    end
+
+    # @return [Array<RPM::Require>] Requires list for this package
+    def requires
+      dependencies(RPM::Require, :requirename, :requireversion, :requireflags)
+    end
+
+    # @return [Array<RPM::Conflicts>] Conflicts list for this package
+    def conflicts
+      dependencies(RPM::conflicts, :conflictsname, :conflictsversion, :conflictsflags)
+    end
+
+    # @return [Array<RPM::Obsolete>] Obsoletes list for this package
+    def obsoletes
+      dependencies(RPM::Obsoletes, :obsoletename, :obsoleteversion, :obsoleteflags)
+    end
+
+    # @return [Array<RPM::Changelog>] changelog of the package as an array 
+    def changelog
+      entries = []
+      nametd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+      timetd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+      texttd = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+    
+      min = RPM::FFI::HEADERGET_MINMEM
+      return deps if (RPM::FFI.headerGet(@hdr, :changelogtime, timetd, min) != 1)
+      return deps if (RPM::FFI.headerGet(@hdr, :changelogname, nametd, min) != 1)
+      return deps if (RPM::FFI.headerGet(@hdr, :changelogtext, texttd, min) != 1)
+
+      RPM::FFI.rpmtdInit(timetd)
+      while RPM::FFI.rpmtdNext(timetd) != -1
+        entry = RPM::ChangeLog.new
+        entry.time = RPM::FFI.rpmtdGetUint32(timetd)
+        entry.name = RPM::FFI.rpmtdNextString(nametd)
+        entry.text = RPM::FFI.rpmtdNextString(texttd)
+        entries << entry
+      end
+      entries
+    end
+
+    # 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
+    def [](tag)
+      val = nil
+      tagc = ::FFI::AutoPointer.new(RPM::FFI.rpmtdNew, Package.method(:release_td))
+
+      return nil if (RPM::FFI.headerGet(ptr, tag, tagc, 
+                      RPM::FFI::HEADERGET_MINMEM) == 0)
+
+      type = RPM::FFI.rpmtdType(tagc)
+      count = RPM::FFI.rpmtdCount(tagc)
+      ret_type = RPM::FFI.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::FFI.rpmtdInit(tagc)
+        while RPM::FFI.rpmtdNext(tagc) != -1
+          ret << RPM::FFI.send(method_name, tagc)
+        end
+        return ret
+      end
+      
+      return RPM::FFI.send(method_name, tagc)
+    end
+
+    # @return [String] This package name
+    def name
+      self[:name]
+    end
+
+    # @return [String] This package architecture
+    def arch
+      self[:arch]
+    end
+
+    # TODO signature
+
+    # @return [Version] Version for this package
+    def version
+      v_ptr = ::FFI::MemoryPointer.new(:pointer, 1)
+      r_ptr = ::FFI::MemoryPointer.new(:pointer, 1)
+
+      RPM::FFI.headerNVR(ptr, nil, v_ptr, r_ptr)
+      v = v_ptr.read_pointer.read_string
+      r = r_ptr.read_pointer.read_string
+      v_ptr.free
+      r_ptr.free
+      Version.new(v, r, self[:epoch])
+    end
+
+    # String representation of the package: "name-version-release-arch"
+    # @return [String]
+    def to_s
+      return "" if name.nil?
+      return name if version.nil?
+      return "#{name}-#{version}" if arch.nil?
+      return "#{name}-#{version}-#{arch}"
+    end
+
+    def self.open(filename)
+      # it sucks not using the std File.open here
+      hdr = ::FFI::MemoryPointer.new(:pointer)
+      fd = nil
+      begin
+        fd = RPM::FFI.Fopen(filename, 'r')
+        if RPM::FFI.Ferror(fd) != 0
+          raise "#{filename} : #{RPM::FFI.Fstrerror(fd)}"
+        end
+        RPM.transaction do |ts|
+          rc = RPM::FFI.rpmReadPackageFile(ts.ptr, fd, filename, hdr)
+        end
+      ensure
+        RPM::FFI.Fclose(fd) unless fd.nil?
+      end
+      Package.new(hdr.get_pointer(0))
+    end
+
+    # @visibility private
+    def self.release(ptr)
+      RPM::FFI.headerFree(ptr)
+    end
+
+    # @visibility private
+    def self.release_td(ptr)
+      RPM::FFI.rpmtdFree(ptr)
+    end
+
+    # @visibility private
+    def initialize(hdr=nil)
+      if hdr.nil?
+        @hdr = ::FFI::AutoPointer.new(RPM::FFI.headerNew, Header.method(:release))
+      elsif hdr.is_a?(::FFI::Pointer)
+        # ref
+        hdr = RPM::FFI.headerLink(hdr)
+        @hdr = ::FFI::AutoPointer.new(hdr, Package.method(:release))
+      else
+        raise "Can't initialize header with '#{hdr}'"
+      end
+    end
+
+    # @return [RPM::FFI::Header] header pointer
+    # @visibility private
+    def ptr
+      @hdr
+    end
+
+
+
+  end
+
+end