rpm2 0.1.0

data/lib/rpm/c/rpmts.rb

@@ -0,0 +1,69 @@
+module RPM
+  module C
+    TransFlags = enum(:rpmtransFlags_e, [
+                        :none, 0,
+                        :test, (1 << 0),
+                        :build_probs, (1 << 1),
+                        :noscripts, (1 << 2),
+                        :justdb, (1 << 3),
+                        :notriggers, (1 << 4),
+                        :nodocs, (1 << 5),
+                        :allfiles, (1 << 6),
+                        # bit 7 unused
+                        :nocontexts, (1 << 8),
+                        # bits 9-15 unused
+                        :notriggerprein, (1 << 16),
+                        :nopre, (1 << 17),
+                        :nopost, (1 << 18),
+                        :notriggerin, (1 << 19),
+                        :notriggerun, (1 << 20),
+                        :nopreun, (1 << 21),
+                        :nopostun, (1 << 22),
+                        :notriggerpostun, (11 << 23),
+                        # bits 24-25 unused
+                        :nocollections, (1 << 26),
+                        :nomd5, (1 << 27),
+                        :nofiledigest, (1 << 27),
+                        # bits 28-29 unused
+                        :noconfigs, (1 << 30),
+                        :deploops, (1 << 31)
+                      ])
+
+    typedef :pointer, :rpmts
+    typedef :pointer, :rpmps
+    typedef :rpmFlags, :rpmtransFlags
+
+    attach_function 'rpmtsCheck', [:rpmts], :int
+    attach_function 'rpmtsOrder', [:rpmts], :int
+    attach_function 'rpmtsRun', %i[rpmts rpmps int], :int
+    attach_function 'rpmtsLink', [:rpmts], :rpmts
+    attach_function 'rpmtsCloseDB', [:rpmts], :int
+    attach_function 'rpmtsOpenDB', %i[rpmts int], :int
+    attach_function 'rpmtsInitDB', %i[rpmts int], :int
+    attach_function 'rpmtsGetDBMode', [:rpmts], :int
+    attach_function 'rpmtsSetDBMode', %i[rpmts int], :int
+    attach_function 'rpmtsRebuildDB', [:rpmts], :int
+    attach_function 'rpmtsVerifyDB', [:rpmts], :int
+    attach_function 'rpmtsInitIterator', %i[rpmts rpmDbiTagVal pointer int], :rpmdbMatchIterator
+    # ...
+    attach_function 'rpmtsProblems', [:rpmts], :rpmps
+    # ...
+    attach_function 'rpmtsClean', [:rpmts], :void
+    # more...
+    attach_function 'rpmtsFree', [:rpmts], :pointer
+    # ..
+    attach_function 'rpmtsSetNotifyCallback', %i[rpmts rpmCallbackFunction rpmCallbackData], :int
+    # ...
+    attach_function 'rpmtsRootDir', [:rpmts], :string
+    attach_function 'rpmtsSetRootDir', %i[rpmts string], :int
+    # ...
+    attach_function 'rpmtsGetRdb', [:rpmts], :rpmdb
+    # ..
+    attach_function 'rpmtsFlags', [:rpmts], :rpmtransFlags
+    attach_function 'rpmtsSetFlags', %i[rpmts rpmtransFlags], :rpmtransFlags
+    # ...
+    attach_function 'rpmtsCreate', [], :rpmts
+    attach_function 'rpmtsAddInstallElement', %i[rpmts header fnpyKey int rpmRelocation], :int
+    attach_function 'rpmtsAddEraseElement', %i[rpmts header int], :int
+  end
+end

data/lib/rpm/c/rpmtypes.rb

@@ -0,0 +1,28 @@
+
+module RPM
+  module C
+    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 :uint32, :rpm_off_t
+    typedef :uint64, :rpm_loff_t
+
+    typedef :pointer, :FD_t
+    typedef :pointer, :fnpyKey
+    typedef :pointer, :rpmCallbackData
+
+    typedef :uint64, :rpm_loff_t
+  end
+end

data/lib/rpm/c.rb

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

data/lib/rpm/compat.rb

@@ -0,0 +1,40 @@
+
+module RPM
+  # compatibility
+  TAG.to_h.each do |k, v|
+    const_set "TAG_#{k.to_s.upcase}", v.to_i
+  end
+
+  LOG.to_h.each do |k, v|
+    const_set "LOG_#{k.to_s.upcase}", v.to_i
+  end
+
+  SENSE.to_h.each do |k, v|
+    const_set "SENSE_#{k.to_s.upcase}", v.to_i
+  end
+
+  # RPMFILE_*
+  FILE.to_h.each do |k, v|
+    const_set "FILE_#{k.to_s.upcase}", v.to_i
+  end
+
+  # RPMFILE_STATE_*
+  FILE_STATE.to_h.each do |k, v|
+    const_set "FILE_STATE_#{k.to_s.upcase}", v.to_i
+  end
+
+  # RPMTRANS_FLAG_*
+  TRANS_FLAG.to_h.each do |k, v|
+    const_set "TRANS_FLAG_#{k.to_s.upcase}", v.to_i
+  end
+
+  # RPMPROB_FILTER_*
+  PROB_FILTER.to_h.each do |k, v|
+    const_set "PROB_FILTER_#{k.to_s.upcase}", v.to_i
+  end
+
+  # RPMPROB_FILTER_*
+  MIRE.to_h.each do |k, v|
+    const_set "MIRE_#{k.to_s.upcase}", v.to_i
+  end
+end

data/lib/rpm/db.rb

@@ -0,0 +1,117 @@
+require 'fcntl'
+
+module RPM
+  class DB
+    include Enumerable
+
+    # @visibility private
+    # @param ts [Transaction] transaction object
+    def initialize(ts, opts = {})
+      opts[:writable] ||= false
+
+      @ts = ts
+      RPM::C.rpmtsOpenDB(@ts.ptr, opts[:writable] ? Fcntl::O_RDWR | Fcntl::O_CREAT : Fcntl::O_RDONLY)
+    end
+
+    # @return [RPM::MatchIterator] Creates an iterator for +tag+ and +val+
+    def init_iterator(tag, val)
+      @ts.init_iterator(tag, val)
+    end
+
+    #
+    # @yield [Package] Called for each match
+    # @param [Number] key RPM tag key
+    # @param [String] val Value to match
+    # @example
+    #   RPM.transaction do |t|
+    #     t.each_match(RPM::TAG_ARCH, "x86_64") do |pkg|
+    #       puts pkg.name
+    #     end
+    #   end
+    #
+    def each_match(key, val, &block)
+      @ts.each_match(key, val, &block)
+    end
+
+    #
+    # @yield [Package] Called for each package in the database
+    # @example
+    #   db.each do |pkg|
+    #     puts pkg.name
+    #   end
+    #
+    def each(&block)
+      @ts.each(&block)
+    end
+
+    # @visibility private
+    def ptr
+      RPM::C.rpmtsGetRdb(@ts.ptr)
+    end
+
+    def close
+      RPM::C.rpmtsCloseDB(@ts.ptr)
+    end
+
+    def closed?
+      ptr.null?
+    end
+
+    #
+    # The package database is opened, but transactional processing
+    # (@see RPM::DB#transaction) cannot be done for when +writable+ is false.
+    # When +writable+ is +false+ then the generated object gets freezed.
+    # @param [Boolean] writable Whether the database is writable. Default is +false+.
+    # @param [String] root Root path for the database, default is empty.
+    # @return [RPM::DB]
+    #
+    # @example
+    #   db = RPM::DB.open
+    #   db.each do |pkg|
+    #     puts pkg.name
+    #   end
+    #
+    def self.open(_writable = false, root = '/', &block)
+      open_for_transaction(Transaction.new(root: root), writable: false, &block)
+    end
+
+    # @visibility private
+    def self.open_for_transaction(ts, opts = {})
+      db = new(ts, opts)
+      return db unless block_given?
+
+      begin
+        yield db
+      ensure
+        db.close unless db.closed?
+      end
+    end
+
+    # @deprecated Not possible to get home value in
+    #   newer RPM versions
+    def home
+      raise NotImplementedError
+    end
+
+    # @return [String] The root path of the database
+    def root
+      RPM::C.rpmtsRootDir(@ts.ptr)
+    end
+
+    # @deprecated Use RPM::Transaction#each
+    def self.each
+      DB.open do |db|
+        it = MatchIterator.from_ptr(RPM::C.rpmdbInitIterator(db.ptr, 0, nil, 0))
+        if block_given?
+          it.each do |pkg|
+            yield pkg
+          end
+        end
+      end
+    end
+
+    # @return number of instances of +name+ in the
+    # database
+    def count_packages(name); end
+  end
+end

data/lib/rpm/dependency.rb

@@ -0,0 +1,120 @@
+
+module RPM
+  class Dependency
+    # @return [String] dependency name
+    attr_accessor :name
+    # @return [String] dependency version
+    attr_accessor :version
+    # @return [String] dependency flags
+    attr_accessor :flags
+    # @return [Package] package this dependency belongs to
+    attr_accessor :owner
+
+    attr_accessor :nametag
+    attr_accessor :versiontag
+    attr_accessor :flagstag
+
+    def initialize(name, version, flags, owner)
+      RPM::Utils.check_type(version, RPM::Version)
+
+      @name = name
+      @version = version
+      @flags = flags
+      @owner = owner
+    end
+
+    # @param [Package, Dependency, Version] other
+    # @return [Boolean] true if +other+ satisfies this dependency
+    def satisfy?(other)
+      case other
+      when RPM::Package then
+        other.provides.each do |prov|
+          return true if satisfy?(prov)
+        end
+        false
+      when RPM::Dependency then
+        RPM::C.rpmdsCompare(
+          RPM::C.rpmdsSingle(:providename, other.name,
+                             other.version.to_vre, other.flags),
+          RPM::C.rpmdsSingle(:providename, name,
+                             version.to_vre, flags)
+        ) != 0
+      when RPM::Version then
+        RPM::C.rpmdsCompare(
+          RPM::C.rpmdsSingle(:providename, name,
+                             other.to_vre, other.to_vre.empty? ? 0 : :equal),
+          RPM::C.rpmdsSingle(:providename, name,
+                             version.to_vre, flags)
+        ) != 0
+      else
+        raise(TypeError, "#{other} is not a Version or Dependency")
+      end
+    end
+
+    # @return [Boolean] true if '<' or '=<' are used to compare the version
+    def lt?
+      flags & RPM::SENSE[:less]
+    end
+
+    # @return [Boolean] true if '>' or '>=' are used to compare the version
+    def gt?
+      flags & RPM::SENSE[:greater]
+    end
+
+    # @return [Boolean] true if '=', '=<' or '>=' are used to compare the version
+    def eq?
+      flags & RPM::SENSE[:equal]
+    end
+
+    # @return [Boolean] true if '=<' is used to compare the version
+    def le?
+      (flags & RPM::SENSE[:less]) && (flags & RPM::SENSE[:equal])
+    end
+
+    # @return [Boolean] true if '>=' is used to compare the version
+    def ge?
+      (flags & RPM::SENSE[:greater]) && (flags & RPM::SENSE[:equal])
+    end
+
+    # @return [Boolean] true if this is a pre-requires
+    def pre?
+      flags & RPM::SENSE[:prereq]
+    end
+  end
+
+  class Provide < Dependency
+    def initialize(name, version, flags, owner)
+      super(name, version, flags, owner)
+      @nametag = RPM::TAG[:providename]
+      @versiontag = RPM::TAG[:provideversion]
+      @flagstag = RPM::TAG[:provideflags]
+    end
+  end
+
+  class Require < Dependency
+    def initialize(name, version, flags, owner)
+      super(name, version, flags, owner)
+      @nametag = RPM::TAG[:requirename]
+      @versiontag = RPM::TAG[:requireversion]
+      @flagstag = RPM::TAG[:requireflags]
+    end
+  end
+
+  class Conflict < Dependency
+    def initialize(name, version, flags, owner)
+      super(name, version, flags, owner)
+      @nametag = RPM::TAG[:conflictname]
+      @versiontag = RPM::TAG[:conflictversion]
+      @flagstag = RPM::TAG[:conflictflags]
+    end
+  end
+
+  class Obsolete < Dependency
+    def initialize(name, version, flags, owner)
+      super(name, version, flags, owner)
+      @nametag = RPM::TAG[:obsoletename]
+      @versiontag = RPM::TAG[:obsoleteversion]
+      @flagstag = RPM::TAG[:obsoleteflags]
+    end
+  end
+end

data/lib/rpm/file.rb

@@ -0,0 +1,134 @@
+# coding: utf-8
+
+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 & RPM::C::FileAttrs[:config]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as documentation
+    def doc?
+      !(@attr & RPM::C::FileAttrs[:doc]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as do not use
+    # @deprecated RPMFILE_DONOTUSE was removed in recent versions of RPM.
+    def donotuse?
+      msg = 'RPMFILE_DONOTUSE was removed in recent versions of RPM.'
+      warn "#{Kernel.caller.first} #{msg}"
+      raise NotImplementedError
+    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 & RPM::C::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 & RPM::C::FileAttrs[:noreplace]).zero?
+    end
+
+    # @return [Boolean] True if the file is marked as a spec file
+    def is_specfile?
+      !(@attr & RPM::C::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 & RPM::C::FileAttrs[:ghost]).zero?
+    end
+
+    # @return [Boolean] True if the file is a license
+    def license?
+      !(@attr & RPM::C::FileAttrs[:license]).zero?
+    end
+
+    # @return [Boolean] True if the file is a README
+    def readme?
+      !(@attr & RPM::C::FileAttrs[:readme]).zero?
+    end
+
+    # @raise NotImplementedError
+    # @deprecated RPMFILE_EXCLUDE was removed in recent versions of RPM.
+    def exclude?
+      msg = 'RPMFILE_EXCLUDE was removed in recent versions of RPM.'
+      warn "#{Kernel.caller.first} #{msg}"
+      raise NotImplementedError
+    end
+
+    # @return [Boolean] True if the file is replaced during installation
+    def replaced?
+      !(@attr & RPM::C::FileState[:replaced]).zero?
+    end
+
+    # @return [Boolean] True if the file is not installed
+    def notinstalled?
+      !(@attr & RPM::C::FileState[:notinstalled]).zero?
+    end
+
+    # @return [Boolean] True if the file is shared over the network
+    def netshared?
+      !(@attr & RPM::C::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'.freeze
+  GEM_VERSION = '0.1.0'.freeze
+end

data/lib/rpm/match_iterator.rb

@@ -0,0 +1,66 @@
+
+module RPM
+  class MatchIterator
+    include Enumerable
+
+    # @visibility private
+    def self.release(ptr)
+      RPM::C.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::C.rpmdbNextIterator(@ptr)
+      return RPM::Package.new(pkg_ptr) unless pkg_ptr.null?
+      nil
+    end
+
+    # @ return header join key for current position of rpm
+    # database iterator
+    def offset
+      RPM::C.rpmdbGetIteratorOffset(@ptr)
+    end
+
+    def set_iterator_re(tag, mode, string)
+      ret = RPM::C.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)
+      unless version.is_a?(RPM::Version)
+        raise TypeError, 'illegal argument type'
+      end
+
+      set_iterator_re(:version, :default, version.v)
+      set_iterator_re(:release, :default, version.r) if version.r
+      self
+    end
+
+    alias version set_iterator_version
+
+    def get_iterator_count
+      RPM::C.rpmdbGetIteratorCount(@ptr)
+    end
+
+    alias count get_iterator_count
+    alias length get_iterator_count
+  end
+end