arr-pm 0.0.2

data/.batcave/manifest

@@ -0,0 +1,5 @@
+---
+things:
+  ruby:
+    args:
+    - rpm

data/.gitignore

@@ -0,0 +1,13 @@
+# vim
+.*.sw[a-z]
+
+# build byproducts
+build-*/*
+fpm.wiki
+*.gem
+
+# python
+*.pyc
+
+# RVM
+.rvmrc

data/Gemfile

@@ -0,0 +1 @@
+source :rubygems

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2012 Jordan Sissel
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

data/Makefile

@@ -0,0 +1,46 @@
+GEMSPEC=$(shell ls *.gemspec)
+VERSION=$(shell awk -F\" '/spec.version/ { print $$2 }' $(GEMSPEC))
+NAME=$(shell awk -F\" '/spec.name/ { print $$2 }' $(GEMSPEC))
+GEM=$(NAME)-$(VERSION).gem
+
+.PHONY: test
+test:
+	sh notify-failure.sh ruby test/all.rb
+
+.PHONY: testloop
+testloop:
+	while true; do \
+		$(MAKE) test; \
+		$(MAKE) wait-for-changes; \
+	done
+
+.PHONY: serve-coverage
+serve-coverage:
+	cd coverage; python -mSimpleHTTPServer
+
+.PHONY: wait-for-changes
+wait-for-changes:
+	-inotifywait --exclude '\.swp' -e modify $$(find $(DIRS) -name '*.rb'; find $(DIRS) -type d)
+
+.PHONY: package
+package: | $(GEM)
+
+.PHONY: gem
+gem: $(GEM)
+
+$(GEM):
+	gem build $(GEMSPEC)
+
+.PHONY: test-package
+test-package: $(GEM)
+	# Sometimes 'gem build' makes a faulty gem.
+	gem unpack $(GEM)
+	rm -rf ftw-$(VERSION)/
+
+.PHONY: publish
+publish: test-package
+	gem push $(GEM)
+
+.PHONY: install
+install: $(GEM)
+	gem install $(GEM)

data/README.md

@@ -0,0 +1,72 @@
+# ARRRRRRRRRR PM
+
+RPM reader/writer library written in Ruby.
+
+It aims to provide [fpm](https://github.com/jordansissel/fpm) with a way to
+read and write rpms.
+
+## Why not use librpm?
+
+The API is quite confusing in many places, poorly documented in most. I have
+reached out to some CentOS/rpm folks to see what we can do about improving that
+API.
+
+Even still, librpm has dependencies of its own. I want fpm to be able to read
+and write RPMs without requiring and endless chain of dependencies and most
+especially without requiring root access to get things going.
+
+Mainly, if I try to build librpm myself, I get this: "configure: error: missing
+required NSPR / NSS header" and I'm not the burden of dependency resolution on
+fpm users.
+
+## API ideas
+
+It should be possible to do a read+modify+write on an RPM.
+
+### Creating an RPM (proposed API)
+
+    rpm = RPM.new
+
+    # requires and conflicts
+    rpm.requires("name") <= "version" # Something fun-dsl-likef
+    rpm.requires("name", :<=, "version") # Or maybe something like this
+
+    # provides
+    rpm.provides("name")
+
+    # Add some files
+    rpm.files << path
+    rpm.files << path2
+    rpm.files << path3
+
+    # Scripts?
+    rpm.scripts[:preinstall](path_or_script_string)
+    rpm.scripts[:postinstall](path_or_script_string)
+    rpm.scripts[:preuninstall](path_or_script_string)
+    rpm.scripts[:postuninstall](path_or_script_string)
+
+    rpm.write(output_file_name)
+
+### Reading an RPM (proposed API)
+
+    rpm = RPM.read(file)
+
+    rpm.requires   # Array of RPM::Requires ?
+    rpm.provides   # Array of 'Provides' strings?
+    rpm.conflicts  # Array of RPM::Conflicts ?
+    rpm.files      # Array of RPM::File ?
+
+Maybe something like:
+
+    rpm.files.each do |file|
+      # Tags that are defined in rpm header tags
+      # fileclass filecolors filecontexts filedependsn filedependsx filedevices
+      # filedigests fileflags filegroupname fileinodes filelangs filelinktos
+      # filemodes filemtimes filerdevs filesizes fileusername fileverifyflags 
+      #
+      # frankly, we don't care about most of these. Meaningful ones:
+      # username, groupname, size, mtime, mode, linkto
+
+      # file.io could give a nice IO-like thing that let you read the file out
+      # of the rpm
+    end

data/header-verify.rb

@@ -0,0 +1,71 @@
+HEADER_MAGIC = "\x8e\xad\xe8\x01\x00\x00\x00\x00"
+TAG_ENTRY_SIZE = 16 # tag id, type, offset, count == 16 bytes
+
+def read_header(io)
+  # RPM 'header' section looks like:
+  #
+  # MAGIC (8 bytes) index_count (4 bytes), data_length (4 bytes )
+  #
+  # * index_count is the number of 'tags' in this header.
+  # * data_length is a blob containing all the values for the tags
+  #
+  # Header has a header of 'magic' + index_count (4 bytes) + data_length (4 bytes)
+  #p "start of header" => io.pos
+  data = io.read(16).unpack("a8NN")
+
+  # TODO(sissel): @index_count is really a count, rename?
+  @magic, @index_count, @data_length = data
+  if @magic != HEADER_MAGIC
+    puts "Magic value in header was wrong. Expected #{HEADER_MAGIC.inspect}, but got #{@magic.inspect}"
+    exit 1
+  end
+  
+  @index_size = @index_count * TAG_ENTRY_SIZE
+  tag_data = io.read(@index_size)
+  data = io.read(@data_length)
+  #p "end of header" => io.pos
+
+  (0 ... @index_count).each do |i|
+    offset = i * TAG_ENTRY_SIZE
+    entry_data = tag_data[i * TAG_ENTRY_SIZE, TAG_ENTRY_SIZE]
+    tag, tag_type, offset, count  = entry_data.unpack("NNNN")
+    if block_given?
+      yield :tag => tag, :type => tag_type, :offset => offset, :count => count
+    end
+    #entry << data
+  end # each index
+  return 16 + @index_size + @data_length
+end
+
+if ARGV.length != 1
+  puts "Usage: #{$0} blah.rpm"
+  exit 1
+end
+
+rpm = File.new(ARGV[0])
+
+# Read the 'lead' - it's mostly an ignored part of the rpm file.
+lead = rpm.read(96)
+magic, major, minor, type, archnum, name, osnum, signature_type, reserved = lead.unpack("A4CCnnA66nnA16")
+
+puts "RPM file version #{major}.#{minor} (#{signature_type == 5 ? "signed" : "unsigned"})"
+
+if signature_type == 5
+  # Read a header for the rpm signature. This has the same format as a normal
+  # rpm header
+  puts "Checking signature"
+  length = read_header(rpm) do |tag|
+    # print each tag in this header
+    p tag
+  end
+
+  # signature headers are padded up to an 8-byte boundar, details here:
+  # http://rpm.org/gitweb?p=rpm.git;a=blob;f=lib/signature.c;h=63e59c00f255a538e48cbc8b0cf3b9bd4a4dbd56;hb=HEAD#l204
+  # Throw away the pad.
+  rpm.read((length % 8))
+end
+
+# Read the rpm header
+puts "Checking header"
+read_header(rpm)
+p rpm.read(4)

data/lib/arr-pm.rb

@@ -0,0 +1,61 @@
+require "rpm/namespace"
+
+class RPM
+  private
+
+  def initialize
+    #@requires = []
+    #@conflicts = []
+    #@provides = []
+    #@files = []
+    #@scripts = {}
+  end
+
+  def requires(name, operator=nil, version=nil)
+    @requires << [name, operator, version]
+  end # def requires
+
+  def conflicts(name, operator=nil, version=nil)
+    @conflicts << [name, operator, version]
+  end
+
+  def provides(name)
+    @provides << name
+  end
+
+  def self.read(path_or_io)
+    rpmfile = RPM::File.new(path_or_io)
+    signature = rpmfile.signature
+    header = rpmfile.header
+
+    header.tags.each do |tag|
+      p tag
+    end
+
+    # Things we care about in the header:
+    # * name, version, release, epoch, summary, description
+    # * 
+    # * requires, provides, conflicts
+    # * scripts
+    # * payload format
+
+    #payload = rpmfile.payload
+    # Parse the payload, check the rpmfile.header to find tags describing the
+    # format of the payload.
+    # Initial target should be gzipped cpio.
+  end # def self.read
+
+  def files
+    return @files
+  end
+
+  # Write this RPM to an IO-like object (must respond to 'write')
+  def write(io)
+    # write the lead
+    # write the signature?
+    # write the header
+    # write the payload
+  end
+
+  public(:files, :requires, :conflicts, :provides, :write)
+end # class RPM

data/lib/arr-pm/conflicts.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), "namespace")
+require File.join(File.dirname(__FILE__), "requires")
+
+class RPM::Conflicts < RPM::Requires
+end

data/lib/arr-pm/file.rb

@@ -0,0 +1,145 @@
+require File.join(File.dirname(__FILE__), "namespace")
+require File.join(File.dirname(__FILE__), "file", "header")
+require File.join(File.dirname(__FILE__), "file", "lead")
+require File.join(File.dirname(__FILE__), "file", "tag")
+
+# Much of the code here is derived from knowledge gained by reading the rpm
+# source code, but mostly it started making more sense after reading this site:
+# http://www.rpm.org/max-rpm/s1-rpm-file-format-rpm-file-format.html
+
+class RPM::File
+  attr_reader :file
+
+  FLAG_LESS = (1 << 1)    #     RPMSENSE_LESS = (1 << 1),
+  FLAG_GREATER = (1 << 2) #     RPMSENSE_GREATER  = (1 << 2),
+  FLAG_EQUAL = (1 << 3)   #     RPMSENSE_EQUAL  = (1 << 3),
+
+  def initialize(file)
+    if file.is_a?(String)
+      file = File.new(file, "r")
+    end
+    @file = file
+
+  end # def initialize
+
+  # Return the lead for this rpm
+  #
+  # This 'lead' structure is almost entirely deprecated in the RPM file format.
+  def lead
+    if @lead.nil?
+      # Make sure we're at the beginning of the file.
+      @file.seek(0, IO::SEEK_SET)
+      @lead = ::RPM::File::Lead.new(@file)
+
+      # TODO(sissel): have 'read' return number of bytes read?
+      @lead.read
+    end
+    return @lead
+  end # def lead
+
+  # Return the signature header for this rpm
+  def signature
+    lead # Make sure we've parsed the lead...
+
+    # If signature_type is not 5 (HEADER_SIGNED_TYPE), no signature.
+    if @lead.signature_type != Header::HEADER_SIGNED_TYPE
+      @signature = false
+      return
+    end
+
+    if @signature.nil?
+      @signature = ::RPM::File::Header.new(@file)
+      @signature.read
+
+      # signature headers are padded up to an 8-byte boundar, details here:
+      # http://rpm.org/gitweb?p=rpm.git;a=blob;f=lib/signature.c;h=63e59c00f255a538e48cbc8b0cf3b9bd4a4dbd56;hb=HEAD#l204
+      # Throw away the pad.
+      @file.read(@signature.length % 8)
+    end
+
+    return @signature
+  end # def signature
+
+  # Return the header for this rpm.
+  def header
+    signature
+
+    if @header.nil?
+      @header = ::RPM::File::Header.new(@file)
+      @header.read
+    end
+    return @header
+  end # def header
+
+  # Returns a file descriptor for the payload. On first invocation, it seeks to
+  # the start of the payload
+  def payload
+    header
+    if @payload.nil?
+      @payload = @file.clone
+      # The payload starts after the lead, signature, and header. Remember the signature has an
+      # 8-byte boundary-rounding.
+      @payload.seek(@lead.length + @signature.length + @signature.length % 8 + @header.length, IO::SEEK_SET)
+    end
+
+    return @payload
+  end # def payload
+
+  # Extract this RPM to a target directory.
+  #
+  # This should have roughly the same effect as:
+  # 
+  #   % rpm2cpio blah.rpm | (cd {target}; cpio -i --make-directories)
+  def extract(target)
+    if !File.directory?(target)
+      raise Errno::ENOENT.new(target)
+    end
+
+    tags = {}
+    header.tags.each do |tag|
+      tags[tag.tag] = tag.value
+    end 
+    
+    # Extract to the 'target' path
+    #tags[:payloadcompressor] # "xz" or "gzip" or ..?
+    #tags[:payloadformat] # "cpio"
+
+    extractor = IO.popen("#{tags[:payloadcompressor]} -d | (cd #{target}; cpio -i --make-directories)", "w")
+    buffer = ""
+    buffer.force_encoding("BINARY")
+    payload_fd = payload
+    loop do
+      data = payload.read(16384, buffer)
+      break if data.nil? # eof
+      extractor.write(data)
+    end
+    extractor.close
+  end # def extract
+
+  def requires
+    tags = {}
+    header.tags.each do |tag|
+      tags[tag.tag] = tag.value
+    end
+
+    result = []
+    reqs = tags[:requirename].zip(tags[:requireflags], tags[:requireversion])
+    reqs.each do |name, flag, version|
+      result << [name, operator(flag), version]
+    end
+    return result
+  end # def requires
+
+  def operator(flag)
+    have = lambda do |mask|
+      return flag & (mask) == mask
+    end
+    return "=" if have.call(FLAG_EQUAL)
+    return "<=" if have.call(FLAG_LESS | FLAG_EQUAL)
+    return "<<" if have.call(FLAG_LESS)
+    return ">=" if have.call(FLAG_GREATER | FLAG_EQUAL)
+    return ">>" if have.call(FLAG_GREATER)
+  end # def operator
+
+  public(:extract, :payload, :header, :lead, :signature, :initialize, :requires)
+end # class RPM::File

data/lib/arr-pm/file/header.rb

@@ -0,0 +1,89 @@
+require File.join(File.dirname(__FILE__), "..", "namespace")
+require File.join(File.dirname(__FILE__), "tag")
+require "cabin"
+
+class RPM::File::Header
+  include Cabin::Inspectable
+  attr_reader :tags
+  attr_reader :length
+
+  attr_accessor :magic  # 8-byte string magic
+  attr_accessor :index_count  # rpmlib calls this field 'il' unhelpfully
+  attr_accessor :data_length  # rpmlib calls this field 'dl' unhelpfully
+
+  HEADER_SIGNED_TYPE = 5
+  HEADER_MAGIC = "\x8e\xad\xe8\x01\x00\x00\x00\x00"
+  # magic + index_count + data_length
+  HEADER_HEADER_LENGTH = HEADER_MAGIC.length + 4 + 4
+  TAG_ENTRY_SIZE = 16 # tag id, type, offset, count == 16 bytes
+
+  def initialize(file)
+    @file = file
+
+    @inspectables = [:@length, :@index_count, :@data_length]
+    @tags = []
+  end
+
+  def read
+    # TODO(sissel): update the comments here to reflect learnings about rpm
+    # internals
+    # At this point assume we've read and consumed the lead and signature.
+    #len = @rpm.signature.index_length + @rpm.signature
+    #
+    # header size is
+    #     ( @rpm.signature.index_length * size of a header entry )
+    #     + @rpm.signature.data_length
+    #
+    # header 'entries' are an
+    #   int32 (tag id), int32 (tag type), int32  (offset), uint32 (count)
+    #
+    #       len = sizeof(il) + sizeof(dl) + (il * sizeof(struct entryInfo_s)) + dl;
+    # See rpm's header.c, the headerLoad method function for reference.
+
+    # Header always starts with HEADER_MAGIC + index_count(2bytes) +
+    # data_length(2bytes)
+    data = @file.read(HEADER_HEADER_LENGTH).unpack("a8NN")
+    # TODO(sissel): @index_count is really a count, rename?
+    @magic, @index_count, @data_length = data
+    validate
+    
+    @index_size = @index_count * TAG_ENTRY_SIZE
+    tag_data = @file.read(@index_size)
+    data = @file.read(@data_length)
+
+    (0 ... @index_count).each do |i|
+      offset = i * TAG_ENTRY_SIZE
+      entry_data = tag_data[i * TAG_ENTRY_SIZE, TAG_ENTRY_SIZE]
+      entry = entry_data.unpack("NNNN")
+      entry << data
+      tag = ::RPM::File::Tag.new(*entry)
+      @tags << tag
+    end # each index
+
+    @length = HEADER_HEADER_LENGTH + @index_size + @data_length
+  end # def read
+
+  def write
+    raise "not implemented yet"
+    # Sort tags by type (integer value)
+    # emit all tags in order
+    # then emit all data segments in same order
+  end # def write
+
+  def validate
+    # TODO(sissel): raise real exceptions
+    if @magic != ::RPM::File::Header::HEADER_MAGIC
+      raise "Header magic did not match; got #{@magic.inspect}, " \
+            "expected #{::RPM::File::Header::HEADER_MAGIC.inspect}"
+    end
+
+    #if !(0..32).include?(@index_count)
+      #raise "Invalid 'index_count' value #{@index_count}, expected to be in range [0..32]"
+    #end
+
+    #if !(0..8192).include?(@data_length)
+      #raise "Invalid 'data_length' value #{@data_length}, expected to be in range [0..8192]"
+    #end
+  end # def validate
+
+end # class RPM::File::Header

data/lib/arr-pm/file/lead.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), "..", "namespace")
+require "cabin"
+
+class RPM::File::Lead
+  include Cabin::Inspectable
+
+  #struct rpmlead {
+  attr_accessor :magic #unsigned char magic[4];
+  attr_accessor :major #unsigned char major;
+  attr_accessor :minor #unsigned char minor;
+  attr_accessor :type  #short type;
+  attr_accessor :archnum #short archnum;
+  attr_accessor :name #char name[66];
+  attr_accessor :osnum #short osnum;
+  attr_accessor :signature_type #short signature_type;
+  attr_accessor :reserved #char reserved[16];
+  #}
+  
+  attr_accessor :length
+
+  def initialize(file)
+    @file = file
+    @inspectables = [:@major, :@minor, :@length, :@type, :@archnum, :@signature_type, :@reserved, :@osnum]
+  end
+
+  def type
+    case @type
+      when 0
+        return :binary
+      when 1
+        return :source
+      else
+        raise "Unknown package 'type' value #{@type}"
+    end
+  end # def type
+
+  def read
+    # Use 'A' here instead of 'a' to trim nulls.
+    @length = 96
+    data = @file.read(@length).unpack("A4CCnnA66nnA16")
+    @magic, @major, @minor, @type, @archnum, @name, \
+      @osnum, @signature_type, @reserved = data
+
+    return nil
+  end # def read
+
+  def write(file)
+    data = [ @magic, @major, @minor, @type, @archnum, @name, \
+             @osnum, @signature_type, @reserved ].pack("a4CCnna66nna16")
+    file.write(data)
+  end # def write
+end # class RPM::File::Lead

data/lib/arr-pm/file/tag.rb

@@ -0,0 +1,307 @@
+require File.join(File.dirname(__FILE__), "..", "namespace")
+require "cabin"
+
+class RPM::File::Tag
+  include Cabin::Inspectable
+
+  attr_accessor :tag
+  attr_accessor :type
+  attr_accessor :offset
+  attr_accessor :count
+  attr_accessor :value
+
+  # This data can be found mostly in rpmtag.h
+  TAG = {
+    61 => :headerimage,
+    62 => :headersignatures,
+    63 => :headerimmutable,
+    64 => :headerregions,
+    100 => :headeri18ntable,
+    256 => :sig_base,
+
+    257 => :sigsize,
+    258 => :siglemd5_1,
+    259 => :sigpgp,
+    260 => :siglemd5_2,
+    261 => :sigmd5,
+    262 => :siggpg,
+    263 => :sigpgp5,
+    264 => :badsha1_1,
+    265 => :badsha1_2,
+    266 => :pubkeys,
+    267 => :dsaheader,
+    268 => :rsaheader,
+    269 => :sha1header,
+    270 => :longsigsize,
+    271 => :longarchivesize,
+
+    1000 => :name,
+    1001 => :version,
+    1002 => :release,
+    1003 => :epoch,
+    1004 => :summary,
+    1005 => :description,
+    1006 => :buildtime,
+    1007 => :buildhost,
+    1008 => :installtime,
+    1009 => :size,
+    1010 => :distribution,
+    1011 => :vendor,
+    1012 => :gif,
+    1013 => :xpm,
+    1014 => :license,
+    1015 => :packager,
+    1016 => :group,
+    1017 => :changelog,
+    1018 => :source,
+    1019 => :patch,
+    1020 => :url,
+    1021 => :os,
+    1022 => :arch,
+    1023 => :prein,
+    1024 => :postin,
+    1025 => :preun,
+    1026 => :postun,
+    1027 => :oldfilenames,
+    1028 => :filesizes,
+    1029 => :filestates,
+    1030 => :filemodes,
+    1031 => :fileuids,
+    1032 => :filegids,
+    1033 => :filerdevs,
+    1034 => :filemtimes,
+    1035 => :filedigests,
+    1036 => :filelinktos,
+    1037 => :fileflags,
+    1038 => :root,
+    1039 => :fileusername,
+    1040 => :filegroupname,
+    1041 => :exclude,
+    1042 => :exclusive,
+    1043 => :icon,
+    1044 => :sourcerpm,
+    1045 => :fileverifyflags,
+    1046 => :archivesize,
+    1047 => :providename,
+    1048 => :requireflags,
+    1049 => :requirename,
+    1050 => :requireversion,
+    1051 => :nosource,
+    1052 => :nopatch,
+    1053 => :conflictflags,
+    1054 => :conflictname,
+    1055 => :conflictversion,
+    1056 => :defaultprefix,
+    1057 => :buildroot,
+    1058 => :installprefix,
+    1059 => :excludearch,
+    1060 => :excludeos,
+    1061 => :exclusivearch,
+    1062 => :exclusiveos,
+    1063 => :autoreqprov,
+    1064 => :rpmversion,
+    1065 => :triggerscripts,
+    1066 => :triggername,
+    1067 => :triggerversion,
+    1068 => :triggerflags,
+    1069 => :triggerindex,
+    1079 => :verifyscript,
+    1080 => :changelogtime,
+    1081 => :changelogname,
+    1082 => :changelogtext,
+    1083 => :brokenmd5,
+    1084 => :prereq,
+    1085 => :preinprog,
+    1086 => :postinprog,
+    1087 => :preunprog,
+    1088 => :postunprog,
+    1089 => :buildarchs,
+    1090 => :obsoletename,
+    1091 => :verifyscriptprog,
+    1092 => :triggerscriptprog,
+    1093 => :docdir,
+    1094 => :cookie,
+    1095 => :filedevices,
+    1096 => :fileinodes,
+    1097 => :filelangs,
+    1098 => :prefixes,
+    1099 => :instprefixes,
+    1100 => :triggerin,
+    1101 => :triggerun,
+    1102 => :triggerpostun,
+    1103 => :autoreq,
+    1104 => :autoprov,
+    1105 => :capability,
+    1106 => :sourcepackage,
+    1107 => :oldorigfilenames,
+    1108 => :buildprereq,
+    1109 => :buildrequires,
+    1110 => :buildconflicts,
+    1111 => :buildmacros,
+    1112 => :provideflags,
+    1113 => :provideversion,
+    1114 => :obsoleteflags,
+    1115 => :obsoleteversion,
+    1116 => :dirindexes,
+    1117 => :basenames,
+    1118 => :dirnames,
+    1119 => :origdirindexes,
+    1120 => :origbasenames,
+    1121 => :origdirnames,
+    1122 => :optflags,
+    1123 => :disturl,
+    1124 => :payloadformat,
+    1125 => :payloadcompressor,
+    1126 => :payloadflags,
+    1127 => :installcolor,
+    1128 => :installtid,
+    1129 => :removetid,
+    1130 => :sha1rhn,
+    1131 => :rhnplatform,
+    1132 => :platform,
+    1133 => :patchesname,
+    1134 => :patchesflags,
+    1135 => :patchesversion,
+    1136 => :cachectime,
+    1137 => :cachepkgpath,
+    1138 => :cachepkgsize,
+    1139 => :cachepkgmtime,
+    1140 => :filecolors,
+    1141 => :fileclass,
+    1142 => :classdict,
+    1143 => :filedependsx,
+    1144 => :filedependsn,
+    1145 => :dependsdict,
+    1146 => :sourcepkgid,
+    1147 => :filecontexts,
+    1148 => :fscontexts,
+    1149 => :recontexts,
+    1150 => :policies,
+    1151 => :pretrans,
+    1152 => :posttrans,
+    1153 => :pretransprog,
+    1154 => :posttransprog,
+    1155 => :disttag,
+    1156 => :suggestsname,
+    1157 => :suggestsversion,
+    1158 => :suggestsflags,
+    1159 => :enhancesname,
+    1160 => :enhancesversion,
+    1161 => :enhancesflags,
+    1162 => :priority,
+    1163 => :cvsid,
+    1164 => :blinkpkgid,
+    1165 => :blinkhdrid,
+    1166 => :blinknevra,
+    1167 => :flinkpkgid,
+    1168 => :flinkhdrid,
+    1169 => :flinknevra,
+    1170 => :packageorigin,
+    1171 => :triggerprein,
+    1172 => :buildsuggests,
+    1173 => :buildenhances,
+    1174 => :scriptstates,
+    1175 => :scriptmetrics,
+    1176 => :buildcpuclock,
+    1177 => :filedigestalgos,
+    1178 => :variants,
+    1179 => :xmajor,
+    1180 => :xminor,
+    1181 => :repotag,
+    1182 => :keywords,
+    1183 => :buildplatforms,
+    1184 => :packagecolor,
+    1185 => :packageprefcolor,
+    1186 => :xattrsdict,
+    1187 => :filexattrsx,
+    1188 => :depattrsdict,
+    1189 => :conflictattrsx,
+    1190 => :obsoleteattrsx,
+    1191 => :provideattrsx,
+    1192 => :requireattrsx,
+    1193 => :buildprovides,
+    1194 => :buildobsoletes,
+    1195 => :dbinstance,
+    1196 => :nvra,
+    5000 => :filenames,
+    5001 => :fileprovide,
+    5002 => :filerequire,
+    5003 => :fsnames,
+    5004 => :fssizes,
+    5005 => :triggerconds,
+    5006 => :triggertype,
+    5007 => :origfilenames,
+    5008 => :longfilesizes,
+    5009 => :longsize,
+    5010 => :filecaps,
+    5011 => :filedigestalgo,
+    5012 => :bugurl,
+    5013 => :evr,
+    5014 => :nvr,
+    5015 => :nevr,
+    5016 => :nevra,
+    5017 => :headercolor,
+    5018 => :verbose,
+    5019 => :epochnum,
+  }
+
+  # See 'rpmTagType' enum in rpmtag.h
+  TYPE = {
+    0 => :null,
+    1 => :char,
+    2 => :int8,
+    3 => :int16,
+    4 => :int32,
+    5 => :int64,
+    6 => :string,
+    7 => :binary,
+    8 => :string_array,
+    9 => :i18nstring,
+  }
+
+  def initialize(tag_id, type, offset, count, data)
+    @tag = tag_id
+    @type = type
+    @offset = offset
+    @count = count
+
+    @data = data
+
+    @inspectables = [:@tag, :@type, :@offset, :@count, :@value]
+  end # def initialize
+
+  def tag
+    TAG.fetch(@tag, @tag)
+  end # def tag
+
+  def tag_as_int
+    @tag
+  end
+
+  def type
+    TYPE.fetch(@type, @type)
+  end # def type
+
+  def value
+    if !@value
+      case type
+        when :string
+          # string at offset up to first null
+          @value = @data[@offset .. -1][/^[^\0]+/]
+        when :i18nstring
+          # string at offset up to first null
+          @value = @data[@offset .. -1][/^[^\0]+/]
+        when :string_array
+          @value = @data[@offset .. -1].split("\0")[0 ... @count]
+        when :binary
+          @value = @data[@offset, @count]
+        when :int32
+          @value = @data[@offset, 4 * count].unpack("N" * count)
+        when :int16
+          @value = @data[@offset, 2 * count].unpack("n" * count)
+      end # case type
+    end # if !@value
+
+    return @value
+  end # def value
+end # class RPM::File::Tag

data/lib/arr-pm/namespace.rb

@@ -0,0 +1,3 @@
+class RPM
+  class File; end
+end

data/lib/arr-pm/requires.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), "namespace")
+
+class RPM::Requires
+  private
+  def initialize(name)
+    @name = name
+    @version = "0"
+    @operator = ">="
+  end # def initialize
+
+  def condition(operator, version)
+    @operator = operator
+    @version = version
+  end # def condition
+
+  def <=(version); condition(:<=, version) end
+  def >=(version); condition(:>=, version) end
+  def <(version); condition(:<, version) end
+  def >(version); condition(:>, version) end
+  def ==(version); condition(:==, version) end
+
+  public(:initialize, :<=, :>=, :<, :>, :==)
+end

data/notify-failure.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+"$@"
+status=$?
+
+if [ ! -z "$TMUX" ] ; then
+  if [ "$status" -ne 0 ] ; then
+    tmux display-message "Tests Fail"
+  else
+    tmux display-message "Tests OK"
+  fi
+fi
+
+exit $status
+

data/printrpm.rb

@@ -0,0 +1,22 @@
+$: << "lib"
+
+require "rpm/file"
+
+rpm = RPM::File.new(ARGV[0])
+
+#p rpm.lead
+rpm.signature.tags.each do |tag|
+  #p :tag => [tag.tag, tag.type, tag.count, tag.value]
+end
+
+rpm.header.tags.each do |tag|
+  #next unless tag.tag.to_s =~ /(payload|sig)/
+#  p :tag => [tag.tag, tag.type, tag.count, tag.value]
+end
+
+require "awesome_print"
+ap rpm.requires
+
+#payload = rpm.payload
+#fd = File.new("/tmp/rpm.payload", "w")
+#fd.write(rpm.payload.read)

data/rpm.gemspec

@@ -0,0 +1,21 @@
+Gem::Specification.new do |spec|
+  files = %x{git ls-files}.split("\n")
+
+  spec.name = "arr-pm"
+  spec.version = "0.0.2"
+  spec.summary = "RPM reader and writer library"
+  spec.description = "This library allows to you to read and write rpm " \
+    "packages. Written in pure ruby because librpm is not available " \
+    "on all systems"
+  spec.license = "Apache 2"
+
+  spec.add_dependency "cabin", ">0" # for logging. apache 2 license
+  spec.files = files
+  spec.require_paths << "lib"
+  spec.bindir = "bin"
+
+  spec.authors = ["Jordan Sissel"]
+  spec.email = ["jls@semicomplete.com"]
+  #spec.homepage = "..."
+end
+

data/test/all.rb

@@ -0,0 +1,24 @@
+require "rubygems"
+require "minitest/spec"
+require "minitest/autorun"
+
+# Get coverage report
+require "simplecov"
+SimpleCov.start
+
+# Add '../lib' to the require path.
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+def use(path)
+  puts "Loading tests from #{path}"
+  require File.expand_path(path)
+end
+
+dirname = File.dirname(__FILE__)
+use File.join(dirname, "docs.rb")
+
+# Load tests from ./*/**/*.rb (usually ./libraryname/....)
+glob = File.join(dirname, "*", "**", "*.rb")
+Dir.glob(glob).each do |path|
+  use path
+end

data/test/docs.rb

@@ -0,0 +1,40 @@
+require "rubygems"                                                                                               
+require "yard"                                                                                                   
+require File.join(File.expand_path(File.dirname(__FILE__)), "testing")
+
+describe "documentation tests" do
+  before do
+    # Use YARD to parse all ruby files found in '../lib'
+    libdir = File.join(File.dirname(__FILE__), "..", "lib")
+    YARD::Registry.load(Dir.glob(File.join(libdir, "**", "*.rb")))
+    @registry = YARD::Registry.all
+  end
+
+  test "All classes, methods, modules, and constants must be documented" do
+    # Note, the 'find the undocumented things' code here is 
+    # copied mostly from: YARD 0.7.5's lib/yard/cli/stats.rb
+    #
+    # Find all undocumented classes, modules, and constants
+    undocumented = @registry.select do |o| 
+      [:class, :module, :constant].include?(o.type) && o.docstring.blank?
+    end
+
+    # Find all undocumented methods
+    methods = @registry.select { |m| m.type == :method }
+    methods.reject! { |m| m.is_alias? || !m.is_explicit? }
+    undocumented += methods.select do |m| 
+      m.docstring.blank? && !m.overridden_method
+    end
+
+    if (undocumented.length > 0)
+      message = ["The following are not documented"]
+      undocumented.each do |o|
+        message << "* #{o.type.to_s} #{o.to_s} <#{o.file}:#{o.line}>"
+      end
+
+      flunk(message.join("\n"))
+    else
+      pass
+    end
+  end
+end

data/test/testing.rb

@@ -0,0 +1,14 @@
+require "rubygems"
+require "minitest/spec"
+
+# Add '../lib' to the require path.
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+# I don't really like monkeypatching, but whatever, this is probably better
+# than overriding the 'describe' method.
+class MiniTest::Spec
+  class << self
+    # 'it' sounds wrong, call it 'test'
+    alias :test :it
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: arr-pm
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Jordan Sissel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cabin
+  requirement: &18435880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *18435880
+description: This library allows to you to read and write rpm packages. Written in
+  pure ruby because librpm is not available on all systems
+email:
+- jls@semicomplete.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .batcave/manifest
+- .gitignore
+- Gemfile
+- LICENSE
+- Makefile
+- README.md
+- header-verify.rb
+- lib/arr-pm.rb
+- lib/arr-pm/conflicts.rb
+- lib/arr-pm/file.rb
+- lib/arr-pm/file/header.rb
+- lib/arr-pm/file/lead.rb
+- lib/arr-pm/file/tag.rb
+- lib/arr-pm/namespace.rb
+- lib/arr-pm/requires.rb
+- notify-failure.sh
+- printrpm.rb
+- rpm.gemspec
+- test/all.rb
+- test/docs.rb
+- test/testing.rb
+homepage: 
+licenses:
+- Apache 2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: RPM reader and writer library
+test_files: []
+has_rdoc: