slack-utils 0.6.2 → 0.7

data/lib/slackware/package_bundle.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 # Copyright 2010,2011  Vincent Batts, Vienna, VA
 # All rights reserved.
 #
@@ -19,12 +21,12 @@
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 module Slackware
-	class PackageBundle < Package
+  class PackageBundle < Package
                 attr_accessor :archive
 
-		def initialize(name = nil)
-			super
-		end
+    def initialize(name = nil)
+      super
+    end
 
                 def parse(name)
                         super(name)
@@ -37,49 +39,50 @@ module Slackware
                         end
                 end
 
-		def get_file_list
+    def get_file_list
                         pkg = "%s/%s.%s" % [self.path, self.fullname, self.archive]
                         return nil unless File.exist?(pkg)
 
-			e_flag = ""
-			if pkg =~ /txz$/
-				e_flag = "J"
-			elsif pkg =~ /tgz$/
-				e_flag = "z"
-			elsif pkg =~ /tbz$/
-				e_flag = "j"
-			end
-			IO.popen("tar #{e_flag}wtf #{pkg}") {|f|
-				f.readlines.map {|l| l.chomp }
-			} 
-		end
+      e_flag = ""
+      if pkg =~ /txz$/
+        e_flag = "J"
+      elsif pkg =~ /tgz$/
+        e_flag = "z"
+      elsif pkg =~ /tbz$/
+        e_flag = "j"
+      end
+      IO.popen("tar #{e_flag}wtf #{pkg}") {|f|
+        f.readlines.map {|l| l.chomp }
+      } 
+    end
 
-		def read_file(file)
+    def read_file(file)
                         pkg = "%s/%s.%s" % [self.path, self.fullname, self.archive]
                         return nil unless File.exist?(pkg)
 
-			e_flag = ""
-			if pkg =~ /txz$/
-				e_flag = "J"
-			elsif pkg =~ /tgz$/
-				e_flag = "z"
-			elsif pkg =~ /tbz$/
-				e_flag = "j"
-			end
-			IO.popen("tar #{e_flag}xOf #{pkg} #{file}") {|f| f.read }
-		end
+      e_flag = ""
+      if pkg =~ /txz$/
+        e_flag = "J"
+      elsif pkg =~ /tgz$/
+        e_flag = "z"
+      elsif pkg =~ /tbz$/
+        e_flag = "j"
+      end
+      IO.popen("tar #{e_flag}xOf #{pkg} #{file}") {|f| f.read }
+    end
 
-		def inspect
-			"#<%s:0x%x name=%s version=%s arch=%s build=%s tag=%s archive=%s>" % [
-				self.class.name,
-				self.object_id,
-				self.name.inspect,
-				self.version.inspect,
-				self.arch.inspect,
-				self.build,
-				self.tag.inspect,
+    def inspect
+      "#<%s:0x%x name=%s version=%s arch=%s build=%s tag=%s archive=%s>" % [
+        self.class.name,
+        self.object_id,
+        self.name.inspect,
+        self.version.inspect,
+        self.arch.inspect,
+        self.build,
+        self.tag.inspect,
                                 self.archive.inspect
-			]
-		end
-	end
+      ]
+    end
+  end
 end
+# vim : set sw=2 sts=2 et :

data/lib/slackware/paths.rb

@@ -0,0 +1,57 @@
+# Copyright 2010,2011,2012  Vincent Batts, Vienna, VA
+# All rights reserved.
+#
+# Redistribution and use of this source, with or without modification, is
+# permitted provided that the following conditions are met:
+#
+# 1. Redistributions of this source must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module Slackware
+  module Paths
+    INSTALLED_PACKAGES = "/var/log/packages"
+    REMOVED_PACKAGES = "/var/log/removed_packages"
+    INSTALLED_SCRIPTS = "/var/log/scripts"
+    REMOVED_SCRIPTS = "/var/log/removed_scripts"
+    VERSION_FILE = "/etc/slackware-version"
+ 
+    # A helper to return the ROOT directory of the system in question.
+    # Like pkgtools, if the environment has "ROOT" set, use it, otherwise "/"
+    def self::root_dir()
+      return ENV["ROOT"] ? ENV["ROOT"] : "/"
+    end
+    
+    def self::installed_packages(*args)
+      return File.join(root_dir, INSTALLED_PACKAGES, args)
+    end
+
+    def self::removed_packages(*args)
+      return File.join(root_dir, REMOVED_PACKAGES, args)
+    end
+
+    def self::installed_scripts(*args)
+      return File.join(root_dir, INSTALLED_SCRIPTS, args)
+    end
+
+    def self::removed_scripts(*args)
+      return File.join(root_dir, REMOVED_SCRIPTS, args)
+    end
+
+    def self::slackware_version()
+      return File.join(root_dir, VERSION_FILE)
+    end
+  end # module Paths
+end # module Slackware
+
+# vim : set sw=2 sts=2 et :

data/lib/slackware/repo.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 # Copyright 2010,2011  Vincent Batts, Vienna, VA
 # All rights reserved.
 #
@@ -19,144 +21,147 @@
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 require 'slackware/package'
+require 'slackware/log'
 require 'slackware/changelog'
 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
-			else
-				## TODO do some hot parsing of 'repo'
-			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.get(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
-			elsif self.proto =~ /file/
-				if (file.nil?)
-					return Dir.glob(self.path + "slackware" + self.arch + "-" + self.version + "/*")
-				else
-					return File.read(self.path + "slackware" + self.arch + "-" + self.version + "/" + file)
-				end
-			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_data = fetch("ChangeLog.txt")
-				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 @packages.count
-		end
-
-	end
+  # Stub
+  class Repo
+    RE_PACKAGE_NAME    = /^PACKAGE NAME:\s+(.*)\.t[gbx]z\s*/
+    RE_PACKAGE_LOCATION  = /^PACKAGE LOCATION:\s+(.*)$/
+    RE_COMPRESSED_SIZE  = /^PACKAGE SIZE \(compressed\):\s+(.*)$/
+    RE_UNCOMPRESSED_SIZE  = /^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
+      else
+        ## TODO do some hot parsing of 'repo'
+      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.get(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
+      elsif self.proto =~ /file/
+        if (file.nil?)
+          return Dir.glob(self.path + "slackware" + self.arch + "-" + self.version + "/*")
+        else
+          return File.read(self.path + "slackware" + self.arch + "-" + self.version + "/" + file)
+        end
+      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_data = fetch("ChangeLog.txt")
+        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 @packages.count
+    end
+
+  end
 
 
 end
 
+# vim : set sw=2 sts=2 et :

data/lib/slackware/system.rb

@@ -1,4 +1,6 @@
-# Copyright 2010,2011  Vincent Batts, Vienna, VA
+# encoding: UTF-8
+
+# Copyright 2010,2011,2012  Vincent Batts, Vienna, VA
 # All rights reserved.
 #
 # Redistribution and use of this source, with or without modification, is
@@ -19,161 +21,185 @@
 # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 require 'slackware/version'
+require 'slackware/paths'
 require 'slackware/package'
+require 'slackware/log'
 
 module Slackware
-	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:]]+)$/
-
-	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
-			pkgs = installed_packages
-			set = []
-			pkgs.map {|p| p.tag }.uniq.each {|tag|
-				m_set = {}
-				m_set[:tag] = tag
-				m_set[:count] = pkgs.map {|p| p if p.tag == tag }.compact.count
-				set << m_set
-			}
-			return set
-		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.get_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
-			SLACKWARE_VERSION
-		end
-	end
+
+  RE_REMOVED_NAMES = /^(.*)-upgraded-(\d{4}-\d{2}-\d{2}),(\d{2}:\d{2}:\d{2})$/
+  RE_BUILD_TAG = /^([[:digit:]]+)([[:alpha:]]+)$/
+
+  FMT_UPGRADE_TIME = "%F %H:%M:%S"
+
+  class System
+
+    # A debug log helper
+    def self::debug(msg)
+      Slackware::Log.instance.debug(self.name) { msg }
+    end
+
+    def self::installed_packages
+      path = Paths::installed_packages("*")
+      return Dir.glob(path).sort.map {|p| Package.parse(p) }
+    end
+
+    def self::removed_packages
+      path = Paths::removed_packages("*")
+      return Dir.glob(path).sort.map {|p| Package.parse(p) }
+    end
+
+    def self::installed_scripts
+      path = Paths::installed_scripts("*")
+      return Dir.glob(path).sort.map {|s| Script.parse(s) }
+    end
+
+    def self::removed_scripts
+      path = Paths::removed_scripts("*")
+      return Dir.glob(path).sort.map {|s| Script.parse(s) }
+    end
+
+    def self::tags_used
+      pkgs = installed_packages()
+      set = []
+      pkgs.map {|p| p.tag }.uniq.each {|tag|
+        m_set = {}
+        m_set[:tag] = tag
+        m_set[:count] = pkgs.select {|p| p.tag == tag }.count
+        set << m_set
+      }
+      return set
+    end
+
+    def self::with_tag(tag)
+      return installed_packages().select {|pkg| pkg.tag == tag }
+    end
+
+    def self::arch_used
+      return installed_packages().map {|p| p.arch }.uniq
+    end
+
+    def self::with_arch(arch)
+      return installed_packages().select {|pkg| pkg.arch == arch }
+    end
+
+    def self::find_installed(name)
+      d = Dir.new(Paths::installed_packages())
+      return d.select {|p| p.include?(name) }.map {|p| Package.parse(p) }
+    end
+
+    def self::find_removed(name)
+      d = Dir.new(Paths::removed_packages())
+      return d.select {|p| p.include?(name) }.map {|p| Package.parse(p) }
+    end
+
+    # Returns a list of the upgrades for a particular package name
+    # Example:
+    #   Slackware::System.upgrades("xz")
+    #   => [#<Slackware::Package:0x981e6c name="xz" version="5.0.0" arch="x86_64" build=1 tag="">,
+    #   #<Slackware::Package:0x97e04c name="xz" version="4.999.9beta" arch="x86_64" build=1 tag="">]
+    #   Slackware::System.upgrades("fart")
+    #   => []
+    def self::upgrades(pkg)
+      find_removed(pkg).select {|p| (p.name == pkg) }
+    end
+
+    # Return an Array of packages, that were installed after provided +time+
+    # ("installed" meaning the file's mtime)
+    def self::installed_after(time)
+      arr = []
+      Dir.new(Paths::installed_packages()).each {|p|
+        if (File.mtime(Paths::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+
+    # ("installed" meaning the file's mtime)
+    def self::installed_before(time)
+      arr = []
+      Dir.new(Paths::installed_packages()).each {|p|
+        if (File.mtime(Paths::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 = []
+      Dir.new(Paths::removed_packages()).each {|p|
+        if (Paths::installed_packages(p) =~ RE_REMOVED_NAMES)
+          if (Time.strptime($2 + ' ' + $3, fmt=FMT_UPGRADE_TIME) >= 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 = []
+      Dir.new(Paths::removed_packages()).each {|p|
+        if (Paths::installed_packages(p) =~ RE_REMOVED_NAMES)
+          if (Time.strptime($2 + ' ' + $3, fmt=FMT_UPGRADE_TIME) <= 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
+    # Returns an Array, of matching pairs. The pairs are [Slackware::Package, <matching file>]
+    def self::owns_file(file)
+      pkgs = installed_packages()
+      debug('owns_file(): pkgs.count => %d' % pkgs.count)
+      found_files = []
+      file = file.sub(/^\//, "") # clean off the leading '/'
+      re = /#{file}/
+      debug('owns_file(): file Regexp => %s' % re.inspect)
+      pkgs.each {|pkg|
+        pkg.get_owned_files().select {|f|
+          begin
+            f =~ re
+          rescue ArgumentError => ex
+            Log.instance.debug(self.name) {
+              "encoding mismatch: " + f
+            }
+            false # this needs to return false, for the .select
+          end
+        }.each do |f|
+            found_files << [pkg, f]
+        end
+      }
+      return found_files
+    end
+
+    # Return the version of Slackware Linux currently installed
+    def self::version
+      debug(SLACKWARE_VERSION)
+      SLACKWARE_VERSION
+    end
+  end
 
 end
 
+# vim: set sw=2 sts=2 et: