dtrx: comparison scripts/x

-:28dbd52a8bb8
+:29794d4d41aa
 MATCHING_DIRECTORY = 1
 # ONE_DIRECTORY = 2
 BOMB = 3
 EMPTY = 4
-DECOMPRESSED = 5
+COMPRESSED = 5
 mimetypes.encodings_map.setdefault('.bz2', 'bzip2')
 mimetypes.types_map['.exe'] = 'application/x-msdos-program'
 def run_command(command, description, stdout=None, stderr=None, stdin=None):
 def get_filenames(self):
 yield self.basename()
 def check_contents(self):
-return DECOMPRESSED
+return COMPRESSED
 def extract(self, path):
 output = open(path, 'w')
 self.run(['cat'], "output write", stdin=self.archive, stdout=output)
 output.close()
 self.logger = logging.getLogger('x-log')
 self.extractor = extractor
 self.contents = contents
 self.options = options
+##     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):
-checker = self.extractor.name_checker(self.extractor.basename())
+try:
-if self.options.flat:
+self.extractor.extract(self.target)
-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 do_extract(self, directory):
-try:
-self.extractor.extract(directory)
 except ExtractorError, error:
 return str(error)
 def cleanup(self):
+raise NotImplementedError
 if self.options.flat:
 self.cleanup_files()
 else:
 self.cleanup_directory()
 status = subprocess.call(['chmod', '-R', 'u+rw', self.target])
 if status != 0:
 return "%s returned with exit status %s" % (command, status)
+# The "where to extract" table, with options and archive types.
+# This dictates the contents of each can_handle method.
+#
+#         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 = '.'
+cleanup = BaseHandler.cleanup_files
+class OverwriteHandler(BaseHandler):
+def can_handle(contents, options):
+return ((options.flat and (contents == COMPRESSED)) or
+(options.overwrite and (contents != MATCHING_DIRECTORY)))
+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 overwrite(self):
+def can_handle(contents, options):
-return self.do_extract('.')
+return contents == MATCHING_DIRECTORY
+can_handle = staticmethod(can_handle)
-def safe_extract(self):
-tempdir = tempfile.mkdtemp()
+def extract(self):
-result = self.do_extract(tempdir)
+basename = self.extractor.basename()
+self.target = tempfile.mkdtemp()
+result = BaseHandler.extract(self)
 if result is None:
-os.rename(os.path.join(tempdir, self.extractor.basename()),
+tempdir = self.target
-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 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)
 class EmptyHandler(object):
+def can_handle(contents, options):
+return contents == EMPTY
+can_handle = staticmethod(can_handle)
 def __init__(self, extractor, contents, options): pass
 def extract(self): pass
 def cleanup(self): pass
+class BombHandler(BaseHandler):
+def can_handle(contents, options):
+return True
+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,
 'application/x-rpm': RPMExtractor,
 'application/x-cpio': CpioExtractor}
-handler_map = {EMPTY: EmptyHandler,
+handlers = [FlatHandler, OverwriteHandler, MatchHandler, EmptyHandler,
-MATCHING_DIRECTORY: MatchHandler,
+BombHandler]
-DECOMPRESSED: BombHandler}
 class ExtractorApplication(object):
 def __init__(self, arguments):
 self.parse_options(arguments)
 self.setup_logger()
 try:
 extractor = extractor_map[mimetype]
 except KeyError:
 if encoding:
 extractor = CompressionExtractor
+contents = COMPRESSED
 else:
 return "not a known archive type"
 try:
 self.current_extractor = extractor(self.current_filename, mimetype,
 encoding)
 content = self.current_extractor.check_contents()
-handler = handler_map.get(content, BombHandler)
+for handler in handlers:
-self.current_handler = handler(self.current_extractor, content,
+if handler.can_handle(content, self.options):
-self.options)
+self.current_handler = handler(self.current_extractor,
+content, self.options)
+break
 except ExtractorError, error:
 return str(error)
 def recurse(self):
 if not self.options.recursive:

Mercurial > dtrx / file comparison

comparison: scripts/x

scripts/x