slack-utils 0.5.1

data/README.rdoc

@@ -0,0 +1,77 @@
+= slackware utilities
+
+== Summary
+
+A ruby library to access information on the Slackware Linux distribution
+
+== Description
+
+slack-utils
+
+slp - shows installed slackware packages
+  with no args, it will show all.
+  or for each arg it will search the package names.
+
+slf - search installed slackware packages for a file
+  this expects an arg(s), and will output, in grep fashion
+  packages matching your search args.
+
+slt - mtime/install time of slackware packages
+  with no args, it will show all.
+  or for each arg it will search the package names.
+
+sll - list the contents of packages matching the
+
+slo - find files in /etc/, that have been orphaned and left behind
+  by unistalled/upgraded packages
+
+slfindlinked - finds what is linked to your argument, and it's package
+  expects 1 argument passed. 
+
+
+TODO: 
+* 2010-08-20 09:16 <bailey> which is that I need to run a query to show
+	me what packages I'm running are different than the slack-current
+	versions, since I make local ones and forget about it
+* enable `slf` to a relative path, and it determine the absolute path
+
+== Installation
+
+To install the gem 
+ sudo gem install pkg/slack-utils-0.5.0.gem
+
+== Quick Start
+
+Install the gem as above.
+
+Start using the library
+
+ $ irb
+ >> require 'rubygems'
+ >> require 'slackware'
+ >> pkg = Slackware::Packware.new()
+ >> pkg.name = "hello-kitty"
+ >> pkg.version = "1.0"
+
+ or 
+ >> require 'rubygems'
+ >> require 'slackware'
+ >> tags = Slackware::System.tags_used
+ => ["SBo","alien","rlw"]
+
+== Usage
+=== Show data
+
+<b>Note: </b>
+
+==== Examples
+see the exmamples/ files
+
+== Help
+There are many more methods than are documented on this page.  Please explore
+the RDOC to find more functionality.
+
+For more complex examples, please see the examples directory 
+ (GEM_ROOT/gems/slack-utils-<version>/examples/).
+
+You can also contact me for more help or suggestions.

data/bin/slf

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'slackware/utils'
+
+opts = Trollop::options do
+	banner <<-EOS
+
+search for a file within installed Slackware package's FILE LIST.
+
+Usage:
+	slf [options] [pkg search flags] <one of more files>
+	
+	one or more files must be list
+	if no search flags, only names, then those only those matching entries are listed
+EOS
+	opt :pkg, "Package PKGNAME (loose match)", :type => :string
+	opt :Version, "Package VERSION (loose match)", :type => :string
+	opt :arch, "Package ARCH (exact match)", :type => :string
+	opt :build, "Package BUILD (exact match)", :type => :string
+	opt :tag, "Package TAG (loose match)", :type => :string
+end
+
+if (ARGV.count > 0)
+	opts[:all] = true
+end
+
+if (ARGV.count == 0)
+	Trollop::die("one or more files must be provided")
+end
+
+begin
+	print_package_searched_files(build_packages(opts, []), ARGV)
+rescue Interrupt
+	exit 0
+rescue Exception => e
+	puts "ERROR: #{e.message}"
+	exit 1
+end
+

data/bin/slfindlinked

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'slackware/utils'
+
+print_find_linked(ARGV[0])
+

data/bin/sll

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'slackware/utils'
+
+opts = Trollop::options do
+	banner <<-EOS
+
+List owned files for a given Slackware package.
+
+Usage:
+	sll [options] [search flags] [list of names]
+	
+	if no search flags, only names, then those only those matching entries are listed
+
+EOS
+	opt :pkg, "Package PKGNAME (loose match)", :type => :string
+	opt :Version, "Package VERSION (loose match)", :type => :string
+	opt :arch, "Package ARCH (exact match)", :type => :string
+	opt :build, "Package BUILD (exact match)", :type => :string
+	opt :tag, "Package TAG (loose match)", :type => :string
+	opt :force, "force me to show all files", :type => :boolean
+end
+
+# handing through that we are listing owned files
+opts[:list_files] = true
+
+if (opts.keys.grep(/[pkg|Version|arch|build|tag]_given$/).count == 0 && not(opts[:force]))
+	Trollop::die("force me if you really want to see all files ...")
+end
+
+begin
+	print_package_file_list(build_packages(opts, ARGV))
+rescue Interrupt
+	exit 0
+end
+

data/bin/slo

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'slackware/utils'
+
+
+begin
+	print_orphaned_files(find_orphaned_config_files())
+rescue Interrupt
+	exit 0
+rescue Exception => e
+	puts "ERROR: #{e.message}"
+	exit 1
+end
+

data/bin/slp

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'slackware/utils'
+
+opts = Trollop::options do
+	banner <<-EOS
+
+List installed Slackware packages.
+
+Usage:
+	slp [options] [search flags] [list of names]
+	
+	if no flags are used, then all entries are listed
+	if no search flags, only names, then those only those matching entries are listed
+
+EOS
+	opt :color, "Colorize output", :type => :boolean
+	opt :pkg, "Package PKGNAME (loose match)", :type => :string
+	opt :Version, "Package VERSION (loose match)", :type => :string
+	opt :arch, "Package ARCH (exact match)", :type => :string
+	opt :build, "Package BUILD (exact match)", :type => :string
+	opt :tag, "Package TAG (loose match)", :type => :string
+end
+
+if (ARGV.count > 0)
+	opts[:all] = true
+end
+
+begin
+	print_packages(build_packages(opts, ARGV))
+rescue Interrupt
+	exit 0
+end
+

data/bin/slt

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'trollop'
+require 'slackware/utils'
+
+opts = Trollop::options do
+	banner <<-EOS
+
+List (and search) installed Slackware package's times.
+
+Usage:
+	slt [options] [search flags] [list of names]
+	
+	if no flags are used, then all entries are listed
+	if no search flags, only names, then those only those matching entries are listed
+
+EOS
+	opt :color, "Colorize output", :default => false, :type => :boolean
+	opt :epoch, "show time in seconds since 1970-01-01 00:00:00 UTC", :type => :boolean
+	opt :pkg, "Package PKGNAME (loose match)", :type => :string
+	opt :Version, "Package VERSION (loose match)", :type => :string
+	opt :arch, "Package ARCH (exact match)", :type => :string
+	opt :build, "Package BUILD (exact match)", :type => :string
+	opt :tag, "Package TAG (loose match)", :type => :string
+end
+
+# handing through that we are gathering times too
+opts[:time] = true
+
+if (opts.keys.grep(/[pkg|Version|arch|build|tag]_given$/).count == 0)
+	opts[:all] = true
+end
+
+begin
+	print_packages_times(build_packages(opts, ARGV), opts[:epoch])
+rescue Interrupt
+	exit 0
+end
+

data/examples/before_then.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+
+$: <<  File.absolute_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'slackware'
+
+t = Time.now - 10000877
+s = Slackware::System.installed_before(t)
+
+puts "#{s.count} packages installed before #{t}"

data/examples/list_packages.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+
+$: <<  File.absolute_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'slackware'
+
+puts "tags used are: " + Slackware::System.tags_used.to_s
+
+pkg = "kernel-modules"
+if (Slackware::System.is_upgraded?(pkg))
+	puts pkg + " has been upgraded before"
+	Slackware::System.upgrades(pkg).each {|up| printf("%s upgraded from version %s\n", up.upgrade_time, up.version) }
+else
+	puts pkg + " apparently has not ever been upgraded before"
+end
+

data/examples/repo.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/ruby -w
+
+$: <<  File.absolute_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'slackware/repo'
+
+sr = Slackware::Repo.new
+sr.version = "current"
+
+sr.set_packages
+
+printf("%d packages in the slackware%s-%s repo\n", sr.packages.count, sr.arch, sr.version)
+

data/examples/repo_difference.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+
+$: <<  File.absolute_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'slackware'
+
+pkgs = Slackware::System.installed_packages.map {|p| p.name }
+sr = Slackware::Repo.new
+sr.version = "current"
+c = sr.get_changelog
+
+printf("difference between current installation and %s...\n", sr.version)
+printf("%d should be removed\n", (pkgs & c[:removed].map {|p| p.name }).count)
+#p pkgs & c[:removed].map {|p| p.name }
+ca = c[:added].map {|p| p.name }
+printf("%d should be added\n", (ca.count - (pkgs & ca).count))

data/lib/slackware/package.rb

@@ -0,0 +1,193 @@
+
+require 'time'
+
+module Slackware
+	class Package
+		attr_accessor :time, :path, :file, :name, :version, :arch, :build, :tag, :tag_sep, :upgrade_time, :owned_files
+		def initialize(name = nil)
+			self.name = name
+		end
+
+		# pkg.parse instance method for parsing the package information
+		def parse(name)
+			if name.include?("/")
+				self.path = File.dirname(name)
+				name = File.basename(name)
+			end
+			if (name =~ RE_REMOVED_NAMES)
+				name = $1
+				self.upgrade_time = Time.strptime($2 + ' ' + $3, fmt='%F %H:%M:%S')
+			end
+			arr = name.split('-').reverse
+			build = arr.shift
+			if (build.include?("_"))
+				self.tag_sep = "_"
+				self.build = build.split(self.tag_sep)[0]
+				self.tag = build.split(self.tag_sep)[1..-1].join(self.tag_sep)
+			elsif (build =~ RE_BUILD_TAG)
+				self.build = $1
+				self.tag = $2
+			else
+				self.build = build
+			end
+			self.arch = arr.shift
+			self.version = arr.shift
+			self.name = arr.reverse.join('-')
+		end
+
+		# Package.parse class method
+		def self::parse(name)
+			p = self.new()
+			p.parse(name)
+			return p
+		end
+		
+		# Reassemble the package name as it would be in file form
+		def fullname
+			if (self.upgrade_time)
+				time = self.upgrade_time.strftime("%F,%H:%M:%S")
+				return [self.name, self.version, self.arch, [self.build, self.tag].join(self.tag_sep), "upgraded", time].join("-")
+			else
+				return [self.name, self.version, self.arch, [self.build, self.tag].join(self.tag_sep)].join("-")
+			end
+		end
+
+		# Accessor for the PACKAGE DESCRIPTION from the package file
+		def package_description
+			if not(@package_description.nil?)
+				return @package_description
+			end
+
+			f = File.open(self.path + '/' + self.fullname)
+			while true
+				if (f.readline =~ /^PACKAGE DESCRIPTION:\s+(.*)$/)
+					desc = f.take_while {|l| not(l =~ /FILE LIST:/) }.map {|l| l.sub(/^#{self.name}:\s*/, '').chomp }
+					return desc
+				end
+			end
+		end
+
+		# Setter for the PACKAGE DESCRIPTION, in the event you are parsing a repo file
+		def package_description=(desc)
+			@package_description = desc
+		end
+
+		# Accessor for the PACKAGE LOCATION from the package file
+		def package_location
+			if not(@package_location.nil?)
+				return @package_location
+			end
+
+			f = File.open(self.path + '/' + self.fullname)
+			while true
+				if (f.readline =~ /^PACKAGE LOCATION:\s+(.*)$/)
+					return $1
+				end
+			end
+		end
+
+		# Setter for the PACKAGE LOCATION, in the event you are parsing a repo file
+		def package_location=(path)
+			@package_location = path
+		end
+
+		# Accessor for the UNCOMPRESSED PACKAGE SIZE from the package file
+		def uncompressed_size
+			if not(@uncompressed_size.nil?)
+				return @uncompressed_size
+			end
+
+			f = File.open(self.path + '/' + self.fullname)
+			while true
+				if (f.readline =~ /^UNCOMPRESSED PACKAGE SIZE:\s+(.*)$/)
+					return $1
+				end
+			end
+		end
+
+		# Setter for the UNCOMPRESSED PACKAGE SIZE, in the event you are parsing a repo file
+		def uncompressed_size=(size)
+			@uncompressed_size = size
+		end
+
+		# Accessor for the COMPRESSED PACKAGE SIZE from the package file
+		def compressed_size
+			if not(@compressed_size.nil?)
+				return @compressed_size
+			end
+
+			f = File.open(self.path + '/' + self.fullname)
+			while true
+				if (f.readline =~ /^COMPRESSED PACKAGE SIZE:\s+(.*)$/)
+					return $1
+				end
+			end
+		end
+
+		# Setter for the COMPRESSED PACKAGE SIZE, in the event you are parsing a repo file
+		def compressed_size=(size)
+			@compressed_size = size
+		end
+
+		# Accessor for the FILE LIST from the package file
+		# unless the :owned_files symbol is populated
+		def get_owned_files
+			if not(@owned_files.nil?)
+				return @owned_files
+			else
+				f = File.open(self.path + '/' + self.fullname)
+				files = f.drop_while {|l| not( l =~ /^FILE LIST:/) }[2..-1].map {|l| l.chomp }
+				f.close
+				return files
+			end
+		end
+
+		# Set the file list in the package object in memory
+		def set_owned_files
+			if @owned_files.nil?
+				@owned_files = self.get_owned_files
+				return true
+			else
+				return false
+			end
+		end
+
+		# populates and returns self.time
+		def get_time
+			if (self.time.nil? && self.path)
+				if (File.exist?(self.path + "/" + self.fullname))
+					self.time = File.mtime(self.path + "/" + self.fullname)
+				end
+			elsif (self.time.nil? && not(self.path))
+				if (File.exist?(DIR_INSTALLED_PACKAGES + "/" + self.fullname))
+					self.time = File.mtime(DIR_INSTALLED_PACKAGES + "/" + self.fullname)
+				end
+			end
+			return self.time
+		end
+
+		# Fill in the path information
+		def get_path
+			if (self.path.nil? && File.exist?(DIR_INSTALLED_PACKAGES + "/" + self.name))
+				self.path = DIR_INSTALLED_PACKAGE
+				return DIR_INSTALLED_PACKAGE
+			end
+		end
+
+	end
+
+	class Script < Package
+		attr_accessor :script
+
+		def initialize(name = nil)
+			self.script = true
+			super
+		end
+
+		def parse(name)
+			super
+			self.script = true
+		end
+
+	end
+end

data/lib/slackware/repo.rb

@@ -0,0 +1,142 @@
+
+require 'slackware/package'
+require 'slackware/system'
+require 'net/http'
+require 'net/ftp'
+require 'rbconfig'
+
+module Slackware
+
+	# Stub
+	class Repo
+		RE_PACKAGE_NAME		= Regexp.new(/^PACKAGE NAME:\s+(.*)\.t[gbx]z\s*/)
+		RE_PACKAGE_LOCATION	= Regexp.new(/^PACKAGE LOCATION:\s+(.*)$/)
+		RE_COMPRESSED_SIZE	= Regexp.new(/^PACKAGE SIZE \(compressed\):\s+(.*)$/)
+		RE_UNCOMPRESSED_SIZE	= Regexp.new(/^PACKAGE SIZE \(uncompressed\):\s+(.*)$/)
+
+		attr_accessor :proto, :mirror, :path, :version, :arch, :changelog, :packages
+
+		def initialize(repo = nil)
+			@packages = nil
+			if (repo.nil?)
+				self.proto	= "ftp://"
+				self.mirror	= "ftp.osuosl.org"
+				self.path	= "/pub/slackware/"
+				self.version	= begin 
+							  v = Slackware::System.version
+							  if v =~ /(\d+)\.(\d+)\.\d+/
+								  v = $1 + "." + $2
+							  end
+							  v
+						  end
+				self.arch	= begin
+							  a = RbConfig::CONFIG["arch"]
+							  if a =~ /x86_64/
+								  a = "64"
+							  else
+								  a = ""
+							  end
+							  a
+						  end
+			end
+		end
+
+		def fetch(file = nil)
+			if file.nil?
+				url = URI.parse(self.proto + self.mirror + self.path)
+			else
+				url = URI.parse(self.proto + self.mirror + self.path + file)
+			end
+			if self.proto =~ /ftp/
+				ftp = Net::FTP.open(self.mirror)
+				ftp.login
+				ftp.chdir(self.path + "slackware" + self.arch + "-" + self.version)
+				if (file.nil?)
+					data = ftp.list('*')
+				else
+					data = ftp.gettextfile(file, nil)
+				end
+				ftp.close
+				return data
+			elsif self.proto =~ /http/
+				# XXX this is not working yet
+				req = Net::HTTP::Get.new(url.path)
+				res = Net::HTTP.start(url.host, url.port) {|http| http.request(req) }
+				return res
+			else
+				return nil
+			end
+		end
+
+		# Pkg count that _should_ be removed
+		# pkgs = Slackware::System.installed_packages
+		# sr = Slackware::Repo.new
+		# sr.version = "current"
+		# c = get_changelog
+		#(pkgs.map {|p| p.fullname } & c[:removed].map {|p| p.fullname }).count
+		def get_changelog
+			if (@changelog.nil?)
+				changelog = {}
+				changelog_date = fetch("ChangeLog.txt").split(/\n/)
+				actions = %w{removed added upgraded rebuilt}
+				actions.each {|action|
+					changelog[:"#{action}"] = changelog_date.map {|line|
+						if line =~ /^\w+\/(.*)\.t[gx]z:\s+#{action}\.?$/i
+							Slackware::Package.parse($1)
+						end
+					}.compact
+				}
+				return changelog
+			else
+				return @changelog
+			end
+		end
+
+		def set_changelog
+			@changelog = get_changelog
+			return nil
+		end
+
+		def get_packages
+			if (@packages.nil?)
+				pkgs = []
+				fetch("PACKAGES.TXT").split(/\n\n/).each {|p_block|
+					p_block = p_block.split(/\n/).reject {|cell| cell if cell == "" }
+					if (p_block.shift =~ RE_PACKAGE_NAME)
+						pkg = Slackware::Package.parse($1)
+
+						p_block.shift =~ RE_PACKAGE_LOCATION
+						pkg.package_location = $1
+
+						p_block.shift =~ RE_COMPRESSED_SIZE
+						pkg.compressed_size = $1
+
+						p_block.shift =~ RE_UNCOMPRESSED_SIZE
+						pkg.uncompressed_size = $1
+
+						# This is the empty PACKAGE DESCRIPTON: tag
+						p_block.shift
+
+						pkg.package_description = p_block.map {|cell|
+							cell.sub(/^#{pkg.name}:\s*/, '')
+						}
+
+						pkgs << pkg
+					end
+				}
+				return pkgs
+			else
+				return @packages
+			end
+		end
+
+		def set_packages
+			@packages = get_packages
+			return nil
+		end
+
+	end
+
+
+end
+

data/lib/slackware/system.rb

@@ -0,0 +1,165 @@
+
+require 'slackware/package'
+
+module Slackware
+
+	VERSION = begin
+			  data = File.read("/etc/slackware-version")
+			  data =~ /Slackware\s(.*)/
+			  $1
+		  rescue
+			  nil
+		  end
+
+	DIR_INSTALLED_PACKAGES = "/var/log/packages"
+	DIR_REMOVED_PACKAGES = "/var/log/removed_packages"
+	DIR_INSTALLED_SCRIPTS = "/var/log/scripts"
+	DIR_REMOVED_SCRIPTS = "/var/log/removed_scripts"
+	RE_REMOVED_NAMES = /^(.*)-upgraded-(\d{4}-\d{2}-\d{2}),(\d{2}:\d{2}:\d{2})$/
+	RE_BUILD_TAG = /^([[:digit:]]+)([[:alpha:]]+)$/
+
+	def self::version
+		VERSION
+	end
+
+	class System
+
+		def self::installed_packages
+			return Dir.glob(DIR_INSTALLED_PACKAGES + "/*").sort.map {|p| Slackware::Package.parse(p) }
+		end
+
+		def self::removed_packages
+			return Dir.glob(DIR_REMOVED_PACKAGES + "/*").sort.map {|p| Slackware::Package.parse(p) }
+		end
+
+		def self::installed_scripts
+			return Dir.glob(DIR_INSTALLED_SCRIPTS + "/*").sort.map {|s| Script.parse(s) }
+		end
+
+		def self::removed_scripts
+			return Dir.glob(DIR_REMOVED_SCRIPTS + "/*").sort.map {|s| Script.parse(s) }
+		end
+
+		def self::tags_used
+			return installed_packages.map {|p| p.tag }.uniq.compact
+		end
+
+		def self::with_tag(tag)
+			return installed_packages.map {|pkg| pkg if pkg.tag == tag }.compact
+		end
+
+		def self::arch_used
+			return installed_packages.map {|p| p.arch }.uniq.compact
+		end
+
+		def self::with_arch(arch)
+			return installed_packages.map {|pkg| pkg if pkg.arch == arch }.compact
+		end
+
+		def self::find_installed(name)
+			d = Dir.new(DIR_INSTALLED_PACKAGES)
+			return d.map {|p| Package.parse(p) if p.include?(name) }.compact
+		end
+
+		def self::find_removed(name)
+			d = Dir.new(DIR_REMOVED_PACKAGES)
+			return d.map {|p| Package.parse(p) if p.include?(name) }.compact
+		end
+
+		def self::upgrades(pkg)
+			if (m = find_removed(pkg).map {|p| p if (p.name == pkg) }.compact )
+				return m
+			else
+				return nil
+			end
+		end
+
+		# Return an Array of packages, that were installed after provided +time+
+		def self::installed_after(time)
+			arr = []
+			di = Dir.new(DIR_INSTALLED_PACKAGES)
+			di.each {|p|
+				if (File.mtime(DIR_INSTALLED_PACKAGES + "/" + p) >= time)
+					pkg = Package.parse(p)
+					pkg.get_time
+					arr << pkg
+				end
+			}
+			return arr
+		end
+
+		# Return an Array of packages, that were installed before provided +time+
+		def self::installed_before(time)
+			arr = []
+			di = Dir.new(DIR_INSTALLED_PACKAGES)
+			di.each {|p|
+				if (File.mtime(DIR_INSTALLED_PACKAGES + "/" + p) <= time)
+					pkg = Package.parse(p)
+					pkg.get_time
+					arr << pkg
+				end
+			}
+			return arr
+		end
+
+		# Return an Array of packages, that were removed after provided +time+
+		def self::removed_after(time)
+			arr = []
+			dr = Dir.new(DIR_REMOVED_PACKAGES)
+			dr.each {|p|
+				if (DIR_INSTALLED_PACKAGES + "/" + p =~ RE_REMOVED_NAMES)
+					if (Time.strptime($2 + ' ' + $3, fmt='%F %H:%M:%S') >= time)
+						arr << Package.parse(p)
+					end
+				end
+			}
+			return arr
+		end
+
+		# Return an Array of packages, that were removed before provided +time+
+		def self::removed_before(time)
+			arr = []
+			dr = Dir.new(DIR_REMOVED_PACKAGES)
+			dr.each {|p|
+				if (DIR_INSTALLED_PACKAGES + "/" + p =~ RE_REMOVED_NAMES)
+					if (Time.strptime($2 + ' ' + $3, fmt='%F %H:%M:%S') <= time)
+						arr << Package.parse(p)
+					end
+				end
+			}
+			return arr
+		end
+
+		# Check whether a given Slackware::Package has been upgraded before
+		def self::is_upgraded?(pkg)
+			if (find_removed(pkg).map {|p| p.name if p.upgrade_time }.include?(pkg) )
+				return true
+			else
+				return false
+			end
+		end
+
+		# Search installation of Slackware::Package's for what owns the questioned file
+		def self::owns_file(file)
+			pkgs = installed_packages
+			found_files = []
+			file = file.sub(/^\//, "") # clean off the leading '/'
+			re = Regexp::new(/#{file}/)
+			pkgs.each {|pkg|
+				if (found = pkg.owned_files.map {|f| f if f =~ re}.compact)
+					found.each {|f|
+						found_files << [pkg, f]
+					}
+				end
+			}
+			return found_files
+		end
+
+		# Return the version of Slackware Linux currently installed
+		def self::version
+			VERSION
+		end
+	end
+
+end
+

data/lib/slackware/utils.rb

@@ -0,0 +1,264 @@
+#!/usr/bin/env ruby 
+# started - Fri Oct	9 15:48:43 CDT 2009
+# updated for args - Tue Mar 23 14:54:19 CDT 2010
+# Copyright 2009, 2010 Vincent Batts, http://hashbangbash.com/
+
+require 'slackware'
+
+# Variables
+@st = "\033[31;1m"
+@en = "\033[0m"
+
+# Classes
+
+
+# Functions
+def build_packages(opts = {}, args = [])
+	pkgs = Slackware::System.installed_packages
+	
+	if (opts[:time])
+		pkgs = pkgs.each {|p| p.get_time }
+	end
+	if (opts[:all])
+		if (args.count > 0)
+			selected_pkgs = []
+			args.each {|arg|
+				pkgs.each {|pkg|
+					if pkg.fullname =~ /#{arg}/
+						selected_pkgs << pkg
+					end
+				}
+			}
+			pkgs = selected_pkgs.uniq
+			selected_pkgs = nil
+		end
+	end
+	if (opts[:pkg_given])
+		pkgs = pkgs.map {|p|
+			re = /#{opts[:pkg]}/i
+			if p.name =~ re
+				if (opts[:color])
+					p.name = p.name.gsub(re, "#{@st}\\&#{@en}")
+				end
+				p
+			end
+		}.compact
+	end
+	if (opts[:Version_given])
+		pkgs = pkgs.map {|p|
+			re = Regexp.new(Regexp.escape(opts[:Version]))
+			if p.version =~ re
+				if (opts[:color])
+					p.version = p.version.gsub(re, "#{@st}\\&#{@en}")
+				end
+				p
+			end
+		}.compact
+	end
+	if (opts[:arch_given])
+		pkgs = pkgs.map {|p|
+			re = /#{opts[:arch]}/
+			if p.arch =~ re
+				if (opts[:color])
+					p.arch = p.arch.gsub(re, "#{@st}\\&#{@en}")
+				end
+				p
+			end
+		}.compact
+	end
+	if (opts[:build_given])
+		pkgs = pkgs.map {|p|
+			re = /#{opts[:build]}/
+			if p.build =~ re
+				if (opts[:color])
+					p.build = p.build.gsub(re, "#{@st}\\&#{@en}")
+				end
+				p
+			end
+		}.compact
+	end
+	if (opts[:tag_given])
+		pkgs = pkgs.map {|p|
+			re = /#{opts[:tag]}/i
+			if p.tag =~ re
+				if (opts[:color])
+					p.tag = p.tag.gsub(re, "#{@st}\\&#{@en}")
+				end
+				p
+			end
+		}.compact
+	end
+
+	return pkgs
+end
+
+def print_packages(pkgs)
+	if (pkgs.count > 0 && pkgs.first.class == Slackware::Package)
+		pkgs.each {|pkg|
+			printf("%s\n", pkg.fullname )
+		}
+	end
+end
+
+def print_packages_times(pkgs, epoch = false)
+	if (epoch == true)
+		pkgs.each {|pkg| printf("%s : %s\n", pkg.fullname, pkg.time.to_i) }
+	else
+		pkgs.each {|pkg| printf("%s : %s\n", pkg.fullname, pkg.time.to_s) }
+	end
+end
+
+# package file listing
+def print_package_file_list(pkgs)
+	if (pkgs.count > 1)
+		pkgs.each {|pkg|
+			pkg.get_owned_files.each {|line|
+				puts pkg.name + ": " + line
+			}
+		}
+	else
+		pkgs.each {|pkg| puts pkg.get_owned_files }
+	end
+end
+
+# search Array of Slackware::Package's for files
+# and print the items found
+def print_package_searched_files(pkgs, files)
+	found_files = []
+	files.each {|file|
+		found_files = found_files.concat(Slackware::System.owns_file(file))
+	}
+	found_files.each {|file|
+		puts file[0].fullname + ": " + file[1]
+	}
+end
+
+# find orpaned files from /etc/
+# 	* build a list of files from removed_packages
+# 	* check the list to see if they are currently owned by a package
+# 	* check the unowned members, to see if they still exist on the filesystem
+# 	* return existing files
+def find_orphaned_config_files
+	# build a list of config files currently installed
+	installed_config_files = Slackware::System.installed_packages.map {|pkg|
+		pkg.get_owned_files.map {|file|
+			file if (file =~ /^etc\// && not(file =~ /\/$/))
+		}
+	}.flatten.compact
+
+	# this Array is where we'll stash removed packages that have config file to check
+	pkgs = Array.new
+	Slackware::System.removed_packages.each {|r_pkg|
+		# find config files for this removed package
+		config = r_pkg.get_owned_files.grep(/^etc\/.*[\w|\d]$/)
+		# continue if there are none
+		if (config.count > 0)
+			# remove config files that are owned by a currently installed package
+			config = config.map {|file|
+				if (not(installed_config_files.include?(file)) && not(installed_config_files.include?(file + ".new")))
+					file
+				end
+			}.compact
+			# check again, and continue if there are no config files left
+			if (config.count > 0)
+				# otherwise add this package, and its files, to the stack
+				pkgs << {:pkg => r_pkg, :files => config}
+			end
+		end
+	}
+
+	# setup list of files to check whether they still exist on the filesystem
+	files = []
+	pkgs.map {|pkg| files << pkg[:files] }
+	files.flatten!.uniq!
+
+	orphaned_config_files = []
+	files.each {|file|
+		if (File.exist?("/" + file))
+			orphaned_config_files << file
+		end
+	}
+
+	return orphaned_config_files
+
+end
+
+def print_orphaned_files(files)
+	puts files
+end
+
+# XXX This is a work in progress
+# It _works_, but is pretty darn slow ...
+# It would be more efficient to break this out to a separate Class,
+# and use a sqlite database for caching linked dependencies.
+# Categorized by pkg, file, links. based on mtime of the package file, 
+# or maybe even mtime of the shared objects themselves.
+# That way, those entries alone could be updated if they are newer,
+# otherwise it's just a query.
+def find_linked(file_to_find)
+	require 'find'
+
+	dirs = %w{ /lib /lib64 /usr/lib /usr/lib64 /bin /sbin /usr/bin /usr/sbin }
+	re_so = Regexp.new(/ELF.*shared object/)
+	re_exec = Regexp.new(/ELF.*executable/)
+
+	if File.exist?(file_to_find)
+		file_to_find = File.expand_path(file_to_find)
+	end
+	if not(filemagic(File.dirname(file_to_find) + "/" + File.readlink(file_to_find)) =~ re_so)
+		printf("%s is not a shared object\n",file_to_find)
+		return nil
+	end
+
+	includes_linked = []
+	printf("Searching through ... ")
+	dirs.each {|dir|
+		printf("%s ", dir)
+		Find.find(dir) {|file|
+			if File.directory?(file)
+				next
+			end
+			file_magic = filemagic(file)
+			if (file_magic =~ re_so || file_magic =~ re_exec)
+				l = `/usr/bin/ldd #{file} 2>/dev/null `
+				if l.include?(file_to_find)
+					printf(".")
+					l = l.sub(/\t/, '').split(/\n/)
+					includes_linked << {:file => file, :links => l}
+				end
+			end
+		}
+	}
+	printf("\n")
+	return includes_linked
+end
+
+# This is intended to take the return of the find_linked() method
+def packages_of_linked_files(linked_files_arr)
+	pkgs = Slackware::System.installed_packages
+	owned_pkgs = []
+	pkgs.map {|pkg|
+		files.each {|file|
+			if pkg.owned_files.include?(file)
+				owned_pkgs << {:pkg => pkg, :file => file}
+			end
+		}
+	}
+	return owned_pkgs
+end
+
+# Pretty print the output of find_linked()
+def print_find_linked(file_to_find)
+	files = find_linked(file_to_find)
+	printf("files linked to '%s' include:\n", file_to_find)
+	files.each {|file|
+		printf("  %s\n", file)
+	}
+end
+
+private
+
+def filemagic(file)
+	return `/usr/bin/file "#{file}"`.chomp
+end
+

data/lib/slackware.rb

@@ -0,0 +1,3 @@
+require 'slackware/package'
+require 'slackware/system'
+require 'slackware/repo'

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: slack-utils
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  - 1
+  version: 0.5.1
+platform: ruby
+authors: 
+- Vincent Batts
+autorequire: slack-utils
+bindir: bin
+cert_chain: []
+
+date: 2011-11-19 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: " slack-utils is a means by which to access \n\
+  package information on the Slackware Linux OS. \n\
+  See the examples/ for more information.\n  "
+email: vbatts@hashbangbash.com
+executables: 
+- slf
+- slo
+- sll
+- slp
+- slt
+- slfindlinked
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- bin/slf
+- bin/slt
+- bin/slp
+- bin/slo
+- bin/sll
+- bin/slfindlinked
+- examples/list_packages.rb
+- examples/repo_difference.rb
+- examples/before_then.rb
+- examples/repo.rb
+- lib/slackware.rb
+- lib/slackware/utils.rb
+- lib/slackware/package.rb
+- lib/slackware/repo.rb
+- lib/slackware/system.rb
+has_rdoc: true
+homepage: https://github.com/vbatts/slack-utils/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main=README.rdoc
+- --line-numbers
+- --inline-source
+- --title=Slackware utils (slack-utils) 0.5.1 Documentation
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Accessing information for the Slackware Linux distribution
+test_files: []
+