arr-pm 0.0.6 → 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ceb08ab00b24c659ee4f0fd42d8f5c8ad77416ffff3f89e8ee18ec46ddc58383
+  data.tar.gz: b53d4d64c24362fb2cf27606842d8352e9f7d184f9ba3b76eb1e33b3e13b2775
+SHA512:
+  metadata.gz: 441b7c7a0d0851c3c4cadaf7e2e0f20d32388ba4df722ee3f76bfb3a34bb072739daf63739cf19e9d8f221a40a80f999ca47b2825043ded493d1f3363dec3e54
+  data.tar.gz: 815d8fff66bc8672b7e212f6c138795a9029b5e78032d26051ac114e306084f97d01519060427aeb50e9bca29dd49af5d5567370904d8881fc99179184811cd3

data/.rubocop.yml

@@ -0,0 +1,73 @@
+# Let's not argue over this...
+StringLiterals:
+  Enabled: false
+
+# I can't find a reason for raise vs fail.
+SignalException:
+  Enabled: false
+
+# I can't find a reason to prefer 'map' when 'collect' is what I mean.
+# I'm collecting things from a list. Maybe someone can help me understand the
+# semantics here.
+CollectionMethods:
+  Enabled: false
+
+# Why do you even *SEE* trailing whitespace? Because your editor was
+# misconfigured to highlight trailing whitespace, right? Maybe turn that off?
+# ;)
+TrailingWhitespace:
+  Enabled: false
+
+# Line length is another weird problem that somehow in the past 40 years of
+# computing we don't seem to have solved. It's a display problem :(
+LineLength:
+  Max: 9000
+
+# %w() vs [ "x", "y", ... ]
+# The complaint is on lib/pleaserun/detector.rb's map of OS=>Runner,
+# i'll ignore it.
+WordArray:
+  MinSize: 5
+
+# A 20-line method isn't too bad.
+MethodLength:
+  Max: 20
+
+# Hash rockets (=>) forever. Why? Not all of my hash keys are static symbols.
+HashSyntax:
+  EnforcedStyle: hash_rockets
+
+# I prefer explicit return. It makes it clear in the code that the
+# code author intended to return a value from a method.
+RedundantReturn:
+  Enabled: false
+
+# My view on a readable case statement seems to disagree with 
+# what rubocop wants and it doesn't let me configure it other than
+# enable/disable.
+CaseIndentation:
+  Enabled: false
+
+# module This::Module::Definition is good.
+Style/ClassAndModuleChildren:
+  Enabled: true
+  EnforcedStyle: compact
+
+# "in interpolation #{use.some("double quotes is ok")}"
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+# Long-block `if !something ... end` are more readable to me than `unless something ... end`
+Style/NegatedIf:
+  Enabled: false
+
+Style/NumericLiterals:
+  MinDigits: 6
+
+# This kind of style "useless use of %x" assumes code is write-once.
+Style/UnneededPercentX:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false

data/Gemfile

@@ -1 +1,3 @@
-source :rubygems
+source "https://rubygems.org"
+
+gemspec

data/Guardfile

@@ -0,0 +1,77 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/Makefile

@@ -3,25 +3,6 @@ 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)
 

data/arr-pm.gemspec

@@ -2,7 +2,7 @@ Gem::Specification.new do |spec|
   files = %x{git ls-files}.split("\n")
 
   spec.name = "arr-pm"
-  spec.version = "0.0.6"
+  spec.version = "0.0.11"
   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 " \
@@ -16,6 +16,8 @@ Gem::Specification.new do |spec|
 
   spec.authors = ["Jordan Sissel"]
   spec.email = ["jls@semicomplete.com"]
+
+  spec.add_development_dependency "flores", ">0"
   #spec.homepage = "..."
 end
 

data/cpio.rb

@@ -0,0 +1,202 @@
+class BoundedIO
+  attr_reader :length
+  attr_reader :remaining
+
+  def initialize(io, length, &eof_callback)
+    @io = io
+    @length = length
+    @remaining = length
+
+    @eof_callback = eof_callback
+    @eof = false
+  end
+
+  def read(size=nil)
+    return nil if eof?
+    size = @remaining if size.nil?
+    data = @io.read(size)
+    @remaining -= data.bytesize
+    eof?
+    data
+  end
+
+  def sysread(size)
+    raise EOFError, "end of file reached" if eof?
+    read(size)
+  end
+
+  def eof?
+    return false if @remaining > 0
+    return @eof if @eof
+
+    @eof_callback.call
+    @eof = true
+  end
+end
+
+module CPIO
+  FIELDS = [
+    :magic, :ino, :mode, :uid, :gid, :nlink, :mtime, :filesize, :devmajor,
+    :devminor, :rdevmajor, :rdevminor, :namesize, :check
+  ]
+end
+
+class CPIO::ASCIIReader
+  FIELD_SIZES = {
+    :magic => 6,
+    :ino => 8,
+    :mode => 8,
+    :uid => 8,
+    :gid => 8,
+    :nlink => 8,
+    :mtime => 8,
+    :filesize => 8,
+    :devmajor => 8,
+    :devminor => 8,
+    :rdevmajor => 8,
+    :rdevminor => 8,
+    :namesize => 8,
+    :check => 8
+  }
+  HEADER_LENGTH = FIELD_SIZES.reduce(0) { |m, (_, v)| m + v }
+  HEADER_PACK = FIELD_SIZES.collect { |_, v| "A#{v}" }.join
+
+  FIELD_ORDER = [
+    :magic, :ino, :mode, :uid, :gid, :nlink, :mtime, :filesize, :devmajor,
+    :devminor, :rdevmajor, :rdevminor, :namesize, :check
+  ]
+
+  def initialize(io)
+    @io = io
+  end
+
+  private
+
+  def io
+    @io
+  end
+
+  def each(&block)
+    while true
+      entry = read
+      break if entry.nil?
+      # The CPIO format has the end-of-stream marker as a file called "TRAILER!!!"
+      break if entry.name == "TRAILER!!!"
+      block.call(entry, entry.file)
+      verify_correct_read(entry) unless entry.directory?
+    end
+  end
+
+  def verify_correct_read(entry)
+    # Read and throw away the whole file if not read at all.
+    entry.file.tap do |file|
+      if file.nil? ||  file.remaining == 0
+        # All OK! :)
+      elsif file.remaining == file.length
+        file.read(16384) while !file.eof?
+      else 
+        # The file was only partially read? This should be an error by the
+        # user.
+        consumed = file.length - file.remaining
+        raise BadState, "Only #{consumed} bytes were read of the #{file.length} byte file: #{entry.name}"
+      end
+    end
+  end
+
+  def read
+    entry = CPIOEntry.new
+    header = io.read(HEADER_LENGTH)
+    return nil if header.nil?
+    FIELD_ORDER.zip(header.unpack(HEADER_PACK)).each do |field, value|
+      entry.send("#{field}=", value.to_i(16))
+    end
+
+    entry.validate
+    entry.mtime = Time.at(entry.mtime)
+    read_name(entry, @io)
+    read_file(entry, @io)
+    entry
+  end
+
+  def read_name(entry, io)
+    entry.name = io.read(entry.namesize - 1) # - 1 for null terminator
+    nul = io.read(1)
+    raise ArgumentError, "Corrupt CPIO or bug? Name null terminator was not null: #{nul.inspect}" if nul != "\0"
+    padding_data = io.read(padding_name(entry))
+    # Padding should be all null bytes
+    if padding_data != ("\0" * padding_data.bytesize)
+      raise ArgumentError, "Corrupt CPIO or bug? Name null padding was #{padding_name(entry)} bytes: #{padding_data.inspect}"
+    end
+  end
+
+  def read_file(entry, io)
+    if entry.directory?
+      entry.file = nil
+      #read_file_padding(entry, io)
+      nil
+    else
+      entry.file = BoundedIO.new(io, entry.filesize) do
+        read_file_padding(entry, io)
+      end
+    end
+  end
+
+  def read_file_padding(entry, io)
+    padding_data = io.read(padding_file(entry))
+    if padding_data != ("\0" * padding_data.bytesize)
+      raise ArgumentError, "Corrupt CPIO or bug? File null padding was #{padding_file(entry)} bytes: #{padding_data.inspect}"
+    end
+  end
+
+  def padding_name(entry)
+    # name padding is padding up to a multiple of 4 after header+namesize
+    -(HEADER_LENGTH + entry.namesize) % 4
+  end
+
+  def padding_file(entry)
+    (-(HEADER_LENGTH + entry.filesize + 2) % 4)
+  end
+  public(:each)
+end
+
+class CPIOEntry
+  CPIO::FIELDS.each do |field|
+    attr_accessor field
+  end
+
+  attr_accessor :name
+  attr_accessor :file
+
+  DIRECTORY_FLAG = 0040000
+
+  def validate
+    raise "Invalid magic #{magic.inspect}" if magic != 0x070701
+    raise "Invalid ino #{ino.inspect}" if ino < 0
+    raise "Invalid mode #{mode.inspect}" if mode < 0
+    raise "Invalid uid #{uid.inspect}" if uid < 0
+    raise "Invalid gid #{gid.inspect}" if gid < 0
+    raise "Invalid nlink #{nlink.inspect}" if nlink < 0
+    raise "Invalid mtime #{mtime.inspect}" if mtime < 0
+    raise "Invalid filesize #{filesize.inspect}" if filesize < 0
+    raise "Invalid devmajor #{devmajor.inspect}" if devmajor < 0
+    raise "Invalid devminor #{devminor.inspect}" if devminor < 0
+    raise "Invalid rdevmajor #{rdevmajor.inspect}" if rdevmajor < 0
+    raise "Invalid rdevminor #{rdevminor.inspect}" if rdevminor < 0
+    raise "Invalid namesize #{namesize.inspect}" if namesize < 0
+    raise "Invalid check #{check.inspect}" if check < 0
+  end # def validate
+
+  def read(*args)
+    return nil if directory?
+    file.read(*args)
+  end
+
+  def directory?
+    mode & DIRECTORY_FLAG > 0
+  end
+end
+
+CPIO::ASCIIReader.new(STDIN).each do |entry, file|
+  puts entry.name
+  file.read unless entry.directory?
+end

data/lib/arr-pm/file.rb

@@ -2,6 +2,7 @@ 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")
+require "fcntl"
 
 # 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:
@@ -99,7 +100,11 @@ class RPM::File
     
     extractor = IO.popen("#{tags[:payloadcompressor]} -d | (cd #{target}; cpio -i --quiet --make-directories)", "w")
     buffer = ""
-    buffer.force_encoding("BINARY")
+    begin
+        buffer.force_encoding("BINARY")
+    rescue NoMethodError
+        # Do Nothing
+    end
     payload_fd = payload.clone
     loop do
       data = payload_fd.read(16384, buffer)
@@ -158,24 +163,28 @@ class RPM::File
   #
   # @return Array of [ [name, operator, version], ... ]
   def conflicts
-    return relation(:conflicts)
+    return relation(:conflict)
   end # def conflicts
 
   # Get an array of provides defined in this package.
   #
   # @return Array of [ [name, operator, version], ... ]
   def provides
-    return relation(:provides)
+    return relation(:provide)
   end # def provides
 
   # Get an array of config files
   def config_files
     # this stuff seems to be in the 'enum rpmfileAttrs_e' from rpm/rpmfi.h
     results = []
-    tags[:fileflags].each_with_index do |flag, i|
-      # The :fileflags (and other :file... tags) are an array, in order of
-      # files in the rpm payload, we want a list of paths of config files.
-      results << files[i] if mask?(flag, FLAG_CONFIG_FILE)
+    # short-circuit if there's no :fileflags tag
+    return results unless tags.include?(:fileflags)
+    if !tags[:fileflags].nil?
+      tags[:fileflags].each_with_index do |flag, i|
+        # The :fileflags (and other :file... tags) are an array, in order of
+        # files in the rpm payload, we want a list of paths of config files.
+        results << files[i] if mask?(flag, FLAG_CONFIG_FILE)
+      end
     end
     return results
   end # def config_files
@@ -190,7 +199,11 @@ class RPM::File
 
     lister = IO.popen("#{tags[:payloadcompressor]} -d | cpio -it --quiet", "r+")
     buffer = ""
-    buffer.force_encoding("BINARY")
+    begin
+        buffer.force_encoding("BINARY")
+    rescue NoMethodError
+        # Do Nothing
+    end
     payload_fd = payload.clone
     output = ""
     loop do
@@ -202,12 +215,23 @@ class RPM::File
       begin
         output << lister.read_nonblock(16384)
       rescue Errno::EAGAIN
-        # do nothing
+        # Nothing to read, move on!
       end
     end
     lister.close_write
+
     # Read remaining output
-    output << lister.read
+    begin
+      output << lister.read
+    rescue Errno::EAGAIN
+      # Because read_nonblock enables NONBLOCK the 'lister' fd,
+      # and we may have invoked a read *before* cpio has started
+      # writing, let's keep retrying this read until we get an EOF
+      retry
+    rescue EOFError
+      # At EOF, hurray! We're done reading.
+    end
+
     # Split output by newline and strip leading "."
     @files = output.split("\n").collect { |s| s.gsub(/^\./, "") }
     return @files