rpm 0.0.0 → 0.0.2

data/lib/rpm/transaction.rb

@@ -0,0 +1,130 @@
+require 'rpm'
+
+module RPM
+
+  class Transaction
+
+    def self.release(ptr)
+      RPM::FFI.rpmtsFree(ptr)
+    end
+
+    def initialize(opts={})
+
+      opts[:root] ||= '/'
+
+      @ptr = ::FFI::AutoPointer.new(RPM::FFI.rpmtsCreate, Transaction.method(:release))
+      RPM::FFI.rpmtsSetRootDir(@ptr, opts[:root])
+    end
+
+    # @return [RPM::MatchIterator] Creates an iterator for +tag+ and +val+
+    def init_iterator(tag, val)
+      raise TypeError if (val && !val.is_a?(String))
+      
+      it_ptr = RPM::FFI.rpmtsInitIterator(@ptr, tag.nil? ? 0 : tag, val, 0)
+      
+      raise "Can't init iterator for [#{tag}] -> '#{val}'" if it_ptr.null?
+      return MatchIterator.from_ptr(it_ptr)
+    end
+
+    # @visibility private
+    def ptr
+      @ptr
+    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)
+      it = init_iterator(key, val)
+
+      return it unless block_given?
+
+      it.each(&block)
+    end
+
+    #
+    # @yield [Package] Called for each package in the database
+    # @example
+    #   db.each do |pkg|
+    #     puts pkg.name
+    #   end
+    #
+    def each(&block)
+      each_match(0, nil, &block)
+    end
+
+    # Add a install operation to the transaction
+    # @param [Package] pkg Package to install
+    def install(pkg, key)
+      raise TypeError if not pkg.is_a?(RPM::Package)
+      
+      @keys ||= Array.new
+      raise ArgError, "key must be unique" if @keys.include?(key)
+      @keys << key
+      
+      RPM::FFI.rpmtsAddInstallElement(@ptr, pkg.ptr, key.to_s, 0, nil)
+      nil
+    end
+
+    # Sets the root directory for this transaction
+    # @param [String] root directory
+    def root_dir=(dir)
+      rc = RPM::FFI.rpmtsSetRootDir(@ptr, dir)
+      raise "Can't set #{dir} as root directory" if rc < 0
+    end
+
+    # @return [String ] the root directory for this transaction
+    def root_dir
+      RPM::FFI.rpmtsRootDir(@ptr)
+    end
+
+    def flags=(fl)
+      RPM::FFI.rpmtsSetFlags(@ptr, fl)
+    end
+
+    def flags
+      RPM::FFI.rpmtsFlags(@ptr)
+    end
+
+    # Performs the transaction.
+    # @param [Number] flag Transaction flags, default +RPM::TRANS_FLAG_NONE+
+    # @param [Number] filter Transaction filter, default +RPM::PROB_FILTER_NONE+
+    # @example
+    #   transaction.commit do |sig|
+    # end
+    # @yield [CallbackData] sig Transaction progress
+    def commit
+      self.flags = RPM::FFI::TransFlags[:none]
+
+      callback = Proc.new do |h, what, amount, total, key, data|
+        puts "#{h} #{what} #{amount} #{total} #{key} #{data}"
+      end
+
+      RPM::FFI.rpmtsSetNotifyCallback(@ts, callback, nil)
+
+      rc = RPM::FFI.rpmtsRun(@ptr, nil, :none)
+
+      raise "Transaction Error" if rc < 0
+      
+      if rc > 0
+        ps = RPM::FFI.rpmtsProblems(@ptr)
+        psi = RPM::FFI.rpmpsInitIterator(ps)
+        while (RPM::FFI.rpmpsNextIterator(psi) >= 0)
+          problem = RPM::FFI.rpmpsGetProblem(psi)
+          puts RPM::FFI.rpmProblemString.read_string
+        end
+        RPM::FFI.rpmpsFree(ps)
+      end
+    end
+
+  end
+
+end

data/lib/rpm/utils.rb

@@ -0,0 +1,10 @@
+module RPM
+
+	module Utils
+
+		def self.check_type(var, type)
+			raise(TypeError, "wrong argument type #{var.class} (expected #{type.class})") unless var.is_a?(type)
+		end
+
+	end
+end

data/lib/rpm/version.rb

@@ -1,3 +1,156 @@
+require 'rpm'
+
 module RPM
-  VERSION = "0.0.0"
+
+  class Version
+
+    include Comparable
+
+    # Parses a "epoch:version-release" string
+    # @return [Array] tuple [epoch, version, release]
+    def self.parse_evr(evr)
+      raise ArgumentError, "version can't be nil" if evr.nil?
+      version = evr
+      epoch = nil
+      release = nil
+
+      idx = version.rindex(?-)
+      version, release = version[0..idx-1], version[idx+1..-1] if idx
+      
+      idx = version.index(/\D/)
+      if (idx && version[idx] == ?:)
+        epoch = version[0..idx-1]
+        version = version[idx+1..-1]
+      end
+      return epoch ? epoch.to_i : nil, version, release
+    end
+
+    #
+    # @overload new(vr, e = nil)
+    #   Creates a version object from a string representation
+    #   @param [String] vr version and release in the form "v-r"
+    #   @param [Number] e epoch
+    #   @return [Version]
+    # @overload new(v, r, e = nil)
+    #   Creates a version object from a string representation
+    #   @param [String] v version
+    #   @param [String] r release
+    #   @param [Number] e epoch
+    #   @return [Version]
+    # @example
+    #   RPM:: Version.new "1.0.0-3"
+    #   RPM:: Version.new "1.04"
+    #   RPM:: Version.new "1.0.0-3k", 1
+    #   RPM:: Version.new "2.0.3", "5k"
+    #
+    def initialize(*argv)
+
+      case argv.size
+        when 0
+          raise(ArgumentError "wrong number of arguments (0 for 1..3)")
+        when 1
+          RPM::Utils.check_type(argv[0], String)
+          @e, @v, @r = RPM::Version.parse_evr(argv[0])
+        when 2
+          # (vr, e)
+          RPM::Utils.check_type(argv[0], String)
+          @e, @v, @r = RPM::Version.parse_evr(argv[0])
+          raise(TypeError, "illegal argument value") if not e.nil?
+          @e = argv[1].to_i
+        when 3
+          RPM::Utils.check_type(argv[0], String)
+          RPM::Utils.check_type(argv[1], String)
+          @v = argv[0]
+          @r = argv[1]
+          @e = argv[2].to_i
+        else
+          raise(ArgumentError "too many arguments (#{args.size} for 1..3)")
+      end
+    end
+
+    # @return [String] the version component
+    def v
+      @v
+    end
+
+    # @return [String] the release component
+    #   or +nil+
+    def r
+      @r
+    end
+
+    # @return [String] the epoch component
+    #   or +nil+
+    def e
+      @e
+    end
+
+    # Comparison between versions
+    # @param [Version] other
+    # @return [Number] -1 if +other+ is greater than, 0 if +other+ is equal to,
+    #   and +1 if other is less than version.
+    #
+    # @example
+    #   v1 = RPM::Version.new("3.0-0",1)
+    #   v2 = RPM::Version.new("3.1-0",1)
+    #   v1 <=> v2
+    #   => -1
+    #
+    def <=>(other)
+      RPM::Utils.check_type(other, RPM::Version)
+      ret = RPM::FFI.rpmvercmp(to_vre_epoch_zero, other.to_vre_epoch_zero)
+    end
+
+    # @param [Version] other Version to compare against
+    # @return [Boolean] true if the version is newer than +other+
+    def newer?(other)
+      (self <=> other) > 0
+    end
+
+
+    # @param [Version] other Version to compare against
+    # @return [Boolean] true if the version is older than +other+
+    def older?(other)
+      ! newer?(other)
+    end
+
+    # String representation in the form "v-r"
+    # @return [String]
+    # @note The epoch is not included
+    def to_vr
+      vr = @r.nil? ? "#{@v}" : "#{@v}-#{@r}"
+    end
+
+    # String representation in the form "e:v-r"
+    # @return [String]
+    # @note The epoch is included if present
+    def to_vre(opts={})
+      vr = to_vr
+      vre = @e.nil? ? vr : "#{@e}:#{vr}"
+    end
+
+    # Alias for +to_vr+
+    # @see Version#to_vr
+    def to_s
+      to_vr
+    end
+
+    # Hash based on the version content
+    # @return [String]
+    def hash
+      h = @e.nil? ? 0 : @e;
+      h = (h << 1) ^ @r.hash
+      h = (h << 1) ^ @v.hash
+    end
+
+    # String representation in the form "e:v-r"
+    # @return [String]
+    # @note The epoch is included always. As 0 if not present
+    def to_vre_epoch_zero
+      vr = to_vr
+      vre = @e.nil? ? "0:#{vr}" : "#{@e}:#{vr}"
+    end
+
+  end
+
 end

data/lib/rpm.rb

@@ -1,5 +1,76 @@
-require "rpm/version"
 
-module Rpm
-  # Your code goes here...
+require 'rpm/ffi'
+require 'rpm/package'
+require 'rpm/db'
+require 'rpm/transaction'
+require 'rpm/match_iterator'
+require 'rpm/version'
+require 'rpm/dependency'
+require 'rpm/utils'
+
+module RPM
+
+  module LibC
+    extend ::FFI::Library
+    ffi_lib ::FFI::Library::LIBC
+
+    # call #attach_function to attach to malloc, free, memcpy, bcopy, etc.
+     attach_function :malloc, [:size_t], :pointer
+  end
+
+  TAG = RPM::FFI::Tag
+  LOG = RPM::FFI::Log
+  SENSE = RPM::FFI::Sense
+  FILE = RPM::FFI::FileAttrs
+  FILE_STATE = RPM::FFI::FileState
+  TRANS_FLAG = RPM::FFI::TransFlags
+  PROB_FILTER = RPM::FFI::ProbFilter
+  MIRE = RPM::FFI::RegexpMode
+  
+  # Creates a new transaction and pass it
+  # to the given block
+  #
+  # @param [String] root dir, default '/'
+  #
+  # @example
+  #   RPM.transaction do |ts|
+  #      ...
+  #   end
+  #
+  def self.transaction(root = '/')
+    ts = Transaction.new
+    ts.root_dir = root
+    yield ts
+  end
+
+
+  # @param [String] name Name of the macro
+  # @return [String] value of macro +name+
+  def self.[](name)
+    val = String.new
+    buffer = ::FFI::MemoryPointer.new(:pointer, 1024)
+    buffer.write_string("%{#{name}}")
+    ret = RPM::FFI.expandMacros(nil, nil, buffer, 1024)
+    buffer.read_string
+  end
+
+  # Setup a macro
+  # @param [String] name Name of the macro
+  # @param [String] value Value of the macro or +nil+ to delete it
+  def self.[]=(name, value)
+    if value.nil?
+      RPM::FFI.delMacro(nil, name.to_s)
+    else
+      RPM::FFI.addMacro(nil, name.to_s, nil, value.to_s, RPM::FFI::RMIL_DEFAULT)
+    end
+  end
+
 end
+ 
+RPM::FFI.rpmReadConfigFiles(nil, nil)
+RPM::FFI.rpmInitMacros(nil, RPM::FFI.MACROFILES)
+
+# TODO
+# set verbosity
+
+require 'rpm/compat'

data/rpm.gemspec

@@ -1,18 +1,24 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "rpm/version"
+require "rpm/gem_version"
 
 Gem::Specification.new do |s|
   s.name        = "rpm"
-  s.version     = RPM::VERSION
+  s.version     = RPM::GEM_VERSION
   s.authors     = ["Duncan Mac-Vicar P."]
   s.email       = ["dmacvicar@suse.de"]
   s.homepage    = ""
-  s.summary     = %q{Placeholder for upcoming release of rpm bindings}
-  s.description = %q{Placeholder for new rpm bindings}
+  s.summary     = %q{Ruby bindings for rpm (package manager)}
+  s.description = %q{Ruby bindings for rpm. Almost a drop-in replacement for ruby-rpm. Uses FFI.}
+
+  s.rubyforge_project = "rpm"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "ffi"
 end

data/test/data/a.spec

@@ -0,0 +1,49 @@
+Name:           a
+Version:        1.0
+Release:        0
+License:        GPLv2
+Summary:        Minimal package example
+Url:            http://www.a.com
+Group:          Development
+Source:         a-1.0.tar.gz
+BuildRequires:  c d
+Provides:       something
+BuildRoot:      %{_tmppath}/%{name}-%{version}-build
+
+%description
+Description
+
+%package devel
+Summary:        Development part
+%description devel
+Development headers
+
+%prep
+%setup -q
+
+%build
+%configure
+make %{?_smp_mflags}
+
+%install
+%make_install
+
+%clean
+%{?buildroot:%__rm -rf "%{buildroot}"}
+
+%post
+
+%postun
+
+%files
+%defattr(-,root,root)
+%doc ChangeLog README COPYING
+%{_datadir}/a/README
+
+%files devel
+%{_includedir}/a.h
+
+
+
+%changelog
+

data/test/data/simple.spec

@@ -0,0 +1,42 @@
+Name:           simple
+Version:        1.0
+Release:        0
+License:        GPL
+Summary:        Simple dummy package
+Summary(es):    Paquete simple de muestra
+Url:            http://www.dummmy.com
+Group:          Development
+BuildRoot:      %{_tmppath}/%{name}-%{version}-build
+
+%description
+Dummy package
+
+%description -l es
+Paquete de muestra
+
+%prep
+
+%build
+mkdir -p %{buildroot}%{_datadir}/%{name}
+echo "Hello" > %{buildroot}%{_datadir}/%{name}/README
+echo "Hola" > %{buildroot}%{_datadir}/%{name}/README.es
+
+%install
+
+%clean
+%{?buildroot:%__rm -rf "%{buildroot}"}
+
+%post
+
+%postun
+
+%files
+%defattr(-,root,root)
+%{_datadir}/%{name}/README
+%{_datadir}/%{name}/README.es
+
+%changelog
+* Wed Nov 06 2011 Duncan Mac-Vicar P. <dmacvicar@suse.de>
+- Fix something
+* Tue Nov 05 2011 Duncan Mac-Vicar P. <dmacvicar@suse.de>
+- Fix something else

data/test/helper.rb

@@ -0,0 +1,7 @@
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'rpm'
+
+def fixture(name)
+  File.join(File.dirname(__FILE__), 'data', name)
+end

data/test/test_dependency.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require 'rpm/compat'
+
+class RPM_Dependency_Tests < Test::Unit::TestCase
+    
+    EQ = RPM::SENSE_EQUAL
+    LT = RPM::SENSE_LESS
+    GT = RPM::SENSE_GREATER
+
+    def test_satisfy
+        prv = provides("foo", "2", "1", 0, EQ)
+        req = requires("foo", "1", "1", 0, EQ|GT)
+        assert(req.satisfy?(prv))
+        assert(prv.satisfy?(req))
+        
+        # Different names don't overlap
+        prv = provides("foo", "2", "1", 0, EQ)
+        req = requires("bar", "1", "1", 0, EQ|GT)
+        assert(! req.satisfy?(prv))
+    end
+
+    def provides(name, v, r, e, sense)
+        RPM::Provide.new(name, RPM::Version.new(v, r, e), sense, nil)
+    end
+
+    def requires(name, v, r, e, sense)
+        RPM::Require.new(name, RPM::Version.new(v, r, e), sense, nil)
+    end
+end

data/test/test_file.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class RPM_File_Tests < Test::Unit::TestCase
+  def test_link_to
+    f = RPM::File.new("path", "md5sum", nil, 42, 1, 
+                      "owner", "group", 43, 0777, 44, 45)
+    assert_equal(nil, f.link_to)
+    f = RPM::File.new("path", "md5sum", "link_to", 42, 1, 
+                      "owner", "group", 43, 0777, 44, 45)
+    assert_equal("link_to", f.link_to)
+    end
+end

data/test/test_lib.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class RPM_Lib_Tests < Test::Unit::TestCase
+
+  def test_lib_lib
+    assert_kind_of String, RPM::FFI.RPMVERSION
+    # "x.y.z"
+    assert(RPM::FFI.RPMVERSION.size >= 5)
+    assert_kind_of Fixnum, RPM::FFI.rpm_version_code
+    # >= 4.0.0
+    assert(RPM::FFI.rpm_version_code >= ((4 << 16) + (0 << 8) + (0 << 0)))
+  end
+
+  def test_lib_header
+    ptr = RPM::FFI.headerNew
+    RPM::FFI.headerFree(ptr)
+  end
+
+  def test_lib_ts
+    ts = RPM::FFI.rpmtsCreate
+    RPM::FFI.rpmtsSetRootDir(ts, "/")
+    it = RPM::FFI.rpmtsInitIterator(ts, 0, nil, 0)
+    hdrs = []
+    while (not (hdr = RPM::FFI.rpmdbNextIterator(it)).null?)
+      hdrs << hdr
+      assert_kind_of String, RPM::FFI.headerGetAsString(hdr, :name)
+    end
+    RPM::FFI.rpmdbFreeIterator(it)
+
+  end
+
+  def test_lib_macros
+    assert_kind_of String, RPM::FFI.MACROFILES
+  end
+
+end

data/test/test_package.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class RPM_Header_Tests < Test::Unit::TestCase
+
+  def test_create
+
+    pkg = RPM::Package.create('foo', RPM::Version.new('1.0'))
+    assert_equal 'foo', pkg.name
+    assert_equal '(none)', pkg.signature
+  end
+
+  def test_open
+    
+    pkg = RPM::Package.open(fixture('simple-1.0-0.i586.rpm'))
+    
+    req = RPM::Require.new("simple", RPM::Version.new("1.0", "0"), RPM::SENSE_GREATER|RPM::SENSE_EQUAL, nil)
+    assert req.satisfy?(pkg)
+
+    assert_equal "simple-1.0-0-i586", pkg.to_s
+
+    assert_equal '6895248ed5a081f73d035174329169c7', pkg.signature
+
+    assert_kind_of RPM::Package, pkg
+    assert_equal 'simple', pkg[:name]
+    assert_equal 'i586', pkg[:arch]
+    assert_kind_of RPM::Version, pkg.version
+    assert_equal '1.0-0', pkg.version.to_s
+
+    backup_lang = ENV['LANG']
+
+    ENV['LANG'] = 'C'
+    assert_equal 'Simple dummy package', pkg[:summary]
+    assert_equal 'Dummy package', pkg[:description]
+    
+    ENV['LANG'] = 'es'
+    assert_equal 'Paquete simple de muestra', pkg[:summary]
+    assert_equal 'Paquete de muestra', pkg[:description]
+
+    ENV['LANG'] = backup_lang
+    
+    # Arrays
+    assert_equal ["root", "root"], pkg[:fileusername]
+    assert_equal [6, 5], pkg[:filesizes]
+
+    assert pkg.provides.map(&:name).include?("simple(x86-32)")
+    assert pkg.provides.map(&:name).include?("simple")
+
+    assert pkg.requires.map(&:name).include?("/bin/sh")
+
+    assert pkg.files.map(&:path).include?("/usr/share/simple/README")
+    assert pkg.files.map(&:path).include?("/usr/share/simple/README.es")
+
+    file = pkg.files.select {|x| x.path == "/usr/share/simple/README" }.first
+    assert_nil file.link_to
+    assert !file.symlink?
+
+    assert_equal ["- Fix something", "- Fix something else"], pkg.changelog.map(&:text)
+  end
+
+end

data/test/test_rpm.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class RPM_RPM_Tests < Test::Unit::TestCase
+
+  def test_enum
+    assert RPM::TAG[:not_found]
+  end
+
+  def test_compat
+    #puts RPM::LOG_ALERT
+    #assert_raise(NameError) { RPM::LOG_ALERT }
+
+    #require 'rpm/compat'
+    assert_nothing_raised { RPM::LOG_ALERT }
+    assert_equal RPM::LOG_ALERT, RPM::LOG[:alert]
+  end
+
+  def test_iterator
+    RPM.transaction do |t|
+      assert_kind_of RPM::Transaction, t
+      #t.each do |pkg|
+      #  puts pkg[:name]
+      #end
+    end
+  end
+
+  def test_macro_read
+    assert_equal '/usr', RPM['_usr']
+  end
+
+  def test_macro_write
+    RPM['hoge'] = 'hoge'
+    assert_equal( RPM['hoge'], 'hoge' )
+  end
+
+
+end # class RPM_RPM_Tests < Test::Unit::TestCase