dtrx: comparison scripts/x

-:29794d4d41aa
+:481a2b4be471
 class FilenameChecker(object):
 def __init__(self, original_name):
 self.original_name = original_name
-def is_free(self, filename=None):
+def is_free(self, filename):
-if filename is None:
-filename = self.original_name
-return self._is_free(filename)
-def _is_free(self, filename):
 return not os.path.exists(filename)
 def check(self):
 for suffix in [''] + ['.%s' % (x,) for x in range(1, 10)]:
 filename = '%s%s' % (self.original_name, suffix)
 raise ValueError("all alternatives for name %s taken" %
 (self.original_name,))
 class DirectoryChecker(FilenameChecker):
-def _is_free(self, filename):
+def is_free(self, filename):
 try:
 os.mkdir(filename)
 except OSError, error:
 if error.errno == errno.EEXIST:
 return False
 def __init__(self, extractor, contents, options):
 self.logger = logging.getLogger('x-log')
 self.extractor = extractor
 self.contents = contents
 self.options = options
+self.target = None
-##     def extract(self):
-##         raise NotImplementedError
-##         checker = self.extractor.name_checker(self.extractor.basename())
-##         if self.options.flat:
-##             self.target = '.'
-##             return self.do_extract('.')
-##         elif self.options.overwrite or checker.is_free():
-##             self.target = self.extractor.basename()
-##             return self.overwrite()
-##         else:
-##             self.target = checker.check()
-##             return self.safe_extract()
 def extract(self):
 try:
 self.extractor.extract(self.target)
-except ExtractorError, error:
+except (ExtractorError, IOError, OSError), error:
 return str(error)
 def cleanup(self):
-raise NotImplementedError
+if self.target is None:
-if self.options.flat:
+return
-self.cleanup_files()
-else:
-self.cleanup_directory()
-def cleanup_files(self):
-for filename in self.extractor.get_filenames():
-stat_info = os.stat(filename)
-perms = stat.S_IRUSR | stat.S_IWUSR
-if stat.S_ISDIR(stat_info.st_mode):
-perms |= stat.S_IXUSR
-os.chmod(filename, stat_info.st_mode | perms)
-def cleanup_directory(self):
 command = 'find'
 status = subprocess.call(['find', self.target, '-type', 'd',
 '-exec', 'chmod', 'u+rwx', '{}', ';'])
 if status == 0:
 command = 'chmod'
 #         Flat           Overwrite            None
 # File    basename       basename             FilenameChecked
 # Match   .              .                    tempdir + checked
 # Bomb    .              basename             DirectoryChecked
 class FlatHandler(BaseHandler):
 def can_handle(contents, options):
 return ((options.flat and (contents != COMPRESSED)) or
 (options.overwrite and (contents == MATCHING_DIRECTORY)))
 can_handle = staticmethod(can_handle)
-target = '.'
+def __init__(self, extractor, contents, options):
-cleanup = BaseHandler.cleanup_files
+BaseHandler.__init__(self, extractor, contents, options)
+self.target = '.'
+def cleanup(self):
+for filename in self.extractor.get_filenames():
+stat_info = os.stat(filename)
+perms = stat.S_IRUSR | stat.S_IWUSR
+if stat.S_ISDIR(stat_info.st_mode):
+perms |= stat.S_IXUSR
+os.chmod(filename, stat_info.st_mode | perms)
 class OverwriteHandler(BaseHandler):
 def can_handle(contents, options):
 return ((options.flat and (contents == COMPRESSED)) or
 can_handle = staticmethod(can_handle)
 def __init__(self, extractor, contents, options):
 BaseHandler.__init__(self, extractor, contents, options)
 self.target = self.extractor.basename()
-cleanup = BaseHandler.cleanup_directory
 class MatchHandler(BaseHandler):
 def can_handle(contents, options):
 return contents == MATCHING_DIRECTORY
 can_handle = staticmethod(can_handle)
 def extract(self):
 basename = self.extractor.basename()
-self.target = tempfile.mkdtemp()
+self.target = tempfile.mkdtemp(dir='.')
 result = BaseHandler.extract(self)
 if result is None:
 tempdir = self.target
 checker = self.extractor.name_checker(basename)
 self.target = checker.check()
 os.rename(os.path.join(tempdir, basename), self.target)
 os.rmdir(tempdir)
 return result
-cleanup = BaseHandler.cleanup_directory
 class EmptyHandler(object):
 def can_handle(contents, options):
 return contents == EMPTY
 can_handle = staticmethod(can_handle)
 def __init__(self, extractor, contents, options):
 BaseHandler.__init__(self, extractor, contents, options)
 checker = self.extractor.name_checker(self.extractor.basename())
 self.target = checker.check()
-cleanup = BaseHandler.cleanup_directory
-## class BombHandler(BaseHandler):
-##     def safe_extract(self):
-##         return self.do_extract(self.target)
-##     def overwrite(self):
-##         self.target = self.extractor.basename()
-##         return self.do_extract(self.target)
 extractor_map = {'application/x-tar': TarExtractor,
 'application/zip': ZipExtractor,
 'application/x-msdos-program': ZipExtractor,
 'application/x-debian-package': DebExtractor,
 'application/x-redhat-package-manager': RPMExtractor,
 directory = os.path.join(self.current_directory,
 self.current_handler.target, tail_path)
 self.archives.setdefault(directory, []).append(basename)
 def report(self, function, *args):
-error = function(*args)
+try:
+error = function(*args)
+except (ExtractorError, IOError, OSError), exception:
+error = str(exception)
 if error:
 self.logger.error("%s: %s", self.current_filename, error)
 return False
 return True
 while self.archives:
 self.current_directory, filenames = self.archives.popitem()
 for filename in filenames:
 os.chdir(self.current_directory)
 self.current_filename = filename
-self.cleanup_actions = []
 success = self.report(self.get_extractor)
 if success:
 for name in 'extract', 'cleanup':
 success = (self.report(getattr(self.current_handler,
 name)) and success)

Mercurial > dtrx / file comparison

comparison: scripts/x

scripts/x