rpm 0.0.0 → 0.0.2

data/.gitignore

@@ -2,3 +2,5 @@
 .bundle
 Gemfile.lock
 pkg/*
+*.rbc
+

data/MIT-LICENSE

@@ -0,0 +1,24 @@
+
+Copyright © 2011 Duncan Mac-Vicar Prett <dmacvicar@suse.de>
+Copyright © 2011 SUSE Linux Products GmbH
+Copyright © 2002 Kenta Murata
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,298 @@
+
+= RPM bindings for ruby
+
+* http://github.com/dmacvicar/ruby-rpm
+
+= WARNING
+
+This is an alpha release! There is still work to be done
+
+= Quickstart
+
+== Working with RPM package files
+
+    require 'rpm'
+
+    pkg = RPM::Package.open("file.rpm")
+    pkg.arch => "x86_64"
+
+    pkg.files.each do |file|
+      puts file.path
+    end
+
+    pkg.changelog.each do |entry|
+      puts "#{entry.name} #{entry.time} #{entry.text}"
+    end
+
+== Querying the rpm database
+
+    require 'rpm'    
+
+    RPM.transaction do |ts|
+      ts.each do |pkg|
+        puts pkg
+      end
+    end
+
+= Introduction
+
+This library is a replacement for the ruby-rpm gem, originally
+writen by Kenta Murata around 2002 for the Kondara distribution. Later 
+mantained by David Lutterkort and myself.
+
+Why?
+
+* The original gem supports ancient rpm versions not in use anymore
+* The original gem was written in C using MRI API
+* The #ifdef'ing required to support multiple rpm versions made the code
+  hard to maintain
+
+This gem:
+
+* Is pure ruby
+* Is documented
+* Has as a goal to support only the latest rpm version plus the ones in 
+  use some releases back in popular rpm based distros
+* Uses FFI, so it should work with other interpreters
+  (Because https://github.com/rubinius/rubinius/issues/682 it currently does
+  not work on Rubinius)
+* Does not target rpm5, but it may support it someday
+
+As an example the code that implements RPM::Package was reduced
+from 1130 lines of code to 320.
+
+= Architecture
+
+The gem is divided in two modules:
+
+* RPM::FFI:: which contains the 1:1 mapping to the librpm API
+  Not all functions are attached, only the ones we actually use.
+* RPM:: contains the actual higher level API
+
+= Status, Compatibility and Differences with ruby-rpm
+
+* Tested rpm 4.9 only
+* You can use symbols: instead of RPM::TAG_DESCRIPTION you
+  can use just :description. 'rpm/compat' is by default loaded
+  and provides compatibility with the RPM::TAG_* style constants
+* RPM::DB is not supported. Use RPM::Transaction
+* Spec and Source classes are not implemented yet
+
+== API Checklist and TODO
+
+* RPM
+
+    [ ] RPM#expand
+    [X] RPM#[]
+    [X] RPM#[]=
+    [ ] RPM#readrc
+    [ ] RPM#init_macros
+    [ ] RPM#verbosity
+    [ ] RPM#verbosity=
+
+* RPM::Package
+
+    [X] Package#open
+    [X] Package#new
+    [X] Package#create
+    [ ] Package#load
+    [ ] Package#clear_cache
+    [ ] Package#use_cache
+    [X] Package#[]
+    [ ] Package#delete_tag
+    [X] Package#sprintf
+    [?] Package#signature
+    [X] Package#arch
+    [X] Package#name
+    [X] Package#version
+    [X] Package#files
+    [X] Package#provides
+    [X] Package#requires
+    [X] Package#conflicts
+    [X] Package#obsoletes
+    [X] Package#changelog
+    [ ] Package#add_dependency
+    [ ] Package#add_string
+    [ ] Package#add_string_array
+    [ ] Package#add_int32
+    [ ] Package#dump
+    [X] Package#to_s
+    [ ] Package#inspect
+    [ ] Package#copy_to
+
+* RPM::Dependency
+
+    [X] Dependency#initialize
+    [X] Dependency#name
+    [X] Dependency#version
+    [X] Dependency#flags
+    [X] Dependency#owner
+    [X] Dependency#lt?
+    [X] Dependency#gt?
+    [X] Dependency#eq?
+    [X] Dependency#le?
+    [X] Dependency#ge?
+    [X] Dependency#satisfy?
+    [X] Dependency#nametag
+    [X] Dependency#versiontag
+    [X] Dependency#flagstag
+
+* RPM::Provide
+    [X] Provide#initialize
+
+* RPM::Require
+    [X] Require#initialize
+    [ ] Require#pre?
+
+* RPM::Conflict
+    [X] Conflict#initialize
+
+* RPM::Obsolete
+    [X] Obsolete#initialize
+
+* RPM::ChangeLog
+
+    [X] ChangeLog#time
+    [X] ChangeLog#name
+    [X] ChangeLog#text
+
+* RPM::Version
+
+    [X] Version (Comparable)
+    [X] Version#initialize
+    [X] Version#<=>
+    [X] Version#newer?
+    [X] Version#older?
+    [X] Version#v
+    [X] Version#r
+    [X] Version#e
+    [X] Version#to_s
+    [X] Version#to_vre
+    [X] Version#inspect
+    [X] Version#hash
+
+* RPM::File
+
+    [X] File#initialize
+    [X] File#path
+    [ ] File#to_s (alias path)
+    [X] File#md5sum
+    [X] File#link_to
+    [X] File#size
+    [X] File#mtime
+    [X] File#owner
+    [X] File#group
+    [X] File#rdev
+    [X] File#mode
+    [X] File#attr
+    [X] File#state
+    [X] File#symlink?
+    [X] File#config?
+    [X] File#doc?
+    [X] File#donotuse?
+    [X] File#missingok?
+    [X] File#specfile?
+    [X] File#ghost?
+    [X] File#license?
+    [X] File#readme?
+    [X] File#exclude?
+    [X] File#replaced?
+    [X] File#notinstalled?
+    [X] File#netshared?
+
+* RPM::DB
+
+    [ ] DB (Enumerable)
+    [ ] DB#new
+    [ ] DB#open
+    [ ] DB#init
+    [ ] DB#rebuild
+    [ ] DB#close
+    [ ] DB#closed?
+    [ ] DB#root
+    [ ] DB#home
+    [ ] DB#writable?
+    [ ] DB#each_match
+    [ ] DB#each
+    [ ] DB#transaction
+    [ ] DB#init_iterator
+    [ ] DB#dup
+    [ ] DB#clone
+
+* RPM::MatchIterator
+
+    [X] MatchIterator (Enumerable)
+    [X] MatchIterator#each
+    [X] MatchIterator#next_iterator
+    [X] MatchIterator#offset
+    [X] MatchIterator#set_iterator_re
+    [X] MatchIterator#regexp
+    [X] MatchIterator#set_iterator_version
+    [X] MatchIterator#version
+    [X] MatchIterator#get_iterator_count
+    [X] MatchIterator#length
+
+* RPM::Transaction
+
+    [ ] Transaction#db
+    [ ] Transaction#script_file
+    [ ] Transaction#script_file=
+    [ ] Transaction#install
+    [ ] Transaction#upgrade
+    [ ] Transaction#available
+    [ ] Transaction#delete
+    [ ] Transaction#check
+    [ ] Transaction#order
+    [ ] Transaction#keys
+    [ ] Transaction#commit
+    [ ] Transaction#abort
+    [ ] Transaction#dup
+    [ ] Transaction#clone
+
+* RPM::Source
+
+    [ ] Source#initialize
+    [ ] Source#fullname
+    [ ] Source#to_s (alias fullname)
+    [ ] Source#num
+    [ ] Source#no?
+
+* RPM::Patch
+* RPM::Icon
+
+* RPM::Spec
+
+    [ ] Spec#open
+    [ ] Spec#new
+    [ ] Spec#buildroot
+    [ ] Spec#buildsubdir
+    [ ] Spec#buildarchs
+    [ ] Spec#buildrequires
+    [ ] Spec#build_restrictions
+    [ ] Spec#sources
+    [ ] Spec#packages
+    [ ] Spec#build
+    [ ] Spec#expand_macros
+    [ ] Spec#dup
+    [ ] Spec#clone
+
+== TODO
+
+* Check Package#signature should return String?
+    => ruby-rpm seems to return symbol
+* Food for thought: Package dependencies and changelog
+  methods could just use []. Calling headerGet directly saves
+  us from doing one iteration per attribute
+* Not sure if Spec can be implemented as it was before with 
+  newer rpms.
+
+= LICENSE
+
+* Copyright © 2011 Duncan Mac-Vicar Prett <dmacvicar@suse.de>
+* Copyright © 2011 SUSE Linux Products GmbH
+
+* This gem is a pure-ruby rewrite of ruby-rpm:
+  Copyright © 2002 Kenta Murata. Relicensed with his permission.
+
+Licensed under the MIT license. See MIT-LICENSE for details.
+

data/Rakefile

@@ -1 +1,32 @@
-require 'bundler/gem_tasks'
+$:.push(File.join(File.dirname(__FILE__), 'lib'))
+require "bundler/gem_tasks"
+require 'rpm/gem_version'
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << File.expand_path('../test', __FILE__)
+  t.libs << File.expand_path('../', __FILE__)
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+  t.loader = :direct
+end
+
+extra_docs = ['README*', 'TODO*', 'CHANGELOG*']
+
+begin
+ require 'yard'
+  YARD::Rake::YardocTask.new(:doc) do |t|
+    t.files   = ['lib/**/*.rb', *extra_docs]
+    t.options = ['--no-private']
+  end
+rescue LoadError
+  STDERR.puts "Install yard if you want prettier docs"
+  require 'rdoc/task'
+  Rake::RDocTask.new(:doc) do |rdoc|
+    rdoc.rdoc_dir = "doc"
+    rdoc.title = "rpm for Ruby #{RPM::GEM_VERSION}"
+    extra_docs.each { |ex| rdoc.rdoc_files.include ex }
+  end
+end

data/lib/rpm/compat.rb

@@ -0,0 +1,43 @@
+require 'rpm'
+
+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,125 @@
+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::FFI.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::FFI.rpmtsGetRdb(@ts.ptr)
+    end
+
+    def close
+      RPM::FFI.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::FFI.rpmtsRootDir(@ts.ptr)
+    end
+
+    # @deprecated Use RPM::Transaction#each
+    def self.each
+      DB.open do |db|
+        it = MatchIterator.from_ptr(RPM::FFI.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,132 @@
+require 'rpm'
+
+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 self.satisfy?(prov)
+          end
+          return false
+        when RPM::Dependency then
+          RPM::FFI.rpmdsCompare(
+            RPM::FFI.rpmdsSingle(:providename, other.name,
+              other.version.to_vre, other.flags),
+            RPM::FFI.rpmdsSingle(:providename, name,
+              version.to_vre, flags)) != 0
+        when RPM::Version then
+          RPM::FFI.rpmdsCompare(
+            RPM::FFI.rpmdsSingle(:providename, name,
+              other.to_vre, other.to_vre.empty? ? 0 : :equal),
+            RPM::FFI.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 & RPMSENSE[:equal])
+    end
+
+    # @return [Boolean] true if '>=' is used to compare the version
+    def ge?
+      (flags & RPM::SENSE[:greater]) && (flags & RPMSENSE[: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 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
+
+end

data/lib/rpm/ffi/header.rb

@@ -0,0 +1,37 @@
+
+module RPM
+
+  module FFI
+
+    typedef :pointer, :header
+
+    attach_function 'headerNew', [], :header
+    attach_function 'headerFree', [:header], :header
+    attach_function 'headerLink', [:header], :header
+    # ..
+    HEADERGET_DEFAULT   = 0,        
+    HEADERGET_MINMEM    = (1 << 0)
+    HEADERGET_EXT       = (1 << 1)
+    HEADERGET_RAW       = (1 << 2)
+    HEADERGET_ALLOC     = (1 << 3)
+    HEADERGET_ARGV      = (1 << 4)
+
+    # ..
+    attach_function 'headerGet', [:header, :rpmTagVal, :pointer, :uint32], :int
+    attach_function 'headerPut', [:header, :pointer, :uint32], :int
+    # ...
+    attach_function 'headerFormat', [:header, :string, :pointer], :pointer
+    # ...
+    attach_function 'headerNVR', [:header, :pointer, :pointer, :pointer], :int
+    # ...
+    attach_function 'headerGetAsString', [:header, :rpmTagVal], :string
+    # ...
+    attach_function 'headerPutString', [:header, :rpmTagVal, :string], :int
+    # ...
+    attach_function 'headerPutUint32', [:header, :rpmTagVal, :pointer, :rpm_count_t], :int
+    # ...
+    attach_function 'rpmReadPackageFile', [:header, :FD_t, :string, :pointer], Rc
+
+  end
+
+end