1 files changed, 4 insertions, 74 deletions

diff --git a/libmat/parser.py b/libmat/parser.py
index 8e10ae9..2a82a25 100644
--- a/libmat/parser.py
+++ b/libmat/parser.py
@@ -5,8 +5,6 @@ import os
 import shutil
 import tempfile
 
-import hachoir_core
-import hachoir_editor
 
 import mat
 
@@ -24,19 +22,14 @@ FIELD = object()
 class GenericParser(object):
     """ Parent class of all parsers
     """
-    def __init__(self, filename, parser, mime, backup, is_writable, **kwargs):
+    def __init__(self, filename, mime, backup, is_writable, **kwargs):
         self.filename = ''
-        self.parser = parser
         self.mime = mime
         self.backup = backup
         self.is_writable = is_writable
-        self.editor = hachoir_editor.createEditor(parser)
-        try:
-            self.filename = hachoir_core.cmd_line.unicodeFilename(filename)
-        except TypeError:  # get rid of "decoding Unicode is not supported"
-            self.filename = filename
+        self.filename = filename
         self.basename = os.path.basename(filename)
-        self.output = hachoir_core.cmd_line.unicodeFilename(tempfile.mkstemp()[1])
+        self.output = tempfile.mkstemp()[1]
 
     def __del__(self):
         """ Remove tempfile if it was not used
@@ -48,74 +41,11 @@ class GenericParser(object):
         """
             Check if the file is clean from harmful metadatas
         """
-        for field in self.editor:
-            if self._should_remove(field):
-                return self._is_clean(self.editor)
-        return True
-
-    def _is_clean(self, fieldset):
-        """ Helper method of the `is_clean` one """
-        for field in fieldset:
-            remove = self._should_remove(field)
-            if remove is True:
-                return False
-            if remove is FIELD:
-                if not self._is_clean(field):
-                    return False
-        return True
+        raise NotImplementedError
 
     def remove_all(self):
         """ Remove all compromising fields
         """
-        state = self._remove_all(self.editor)
-        hachoir_core.field.writeIntoFile(self.editor, self.output)
-        self.do_backup()
-        return state
-
-    def _remove_all(self, fieldset):
-        """ Recursive way to handle tree metadatas
-        """
-        try:
-            for field in fieldset:
-                remove = self._should_remove(field)
-                if remove is True:
-                    self._remove(fieldset, field.name)
-                if remove is FIELD:
-                    self._remove_all(field)
-            return True
-        except:
-            return False
-
-    @staticmethod
-    def _remove(fieldset, field):
-        """ Delete the given field
-        """
-        del fieldset[field]
-
-    def get_meta(self):
-        """ Return a dict with all the meta of the file
-        """
-        metadata = {}
-        self._get_meta(self.editor, metadata)
-        return metadata
-
-    def _get_meta(self, fieldset, metadata):
-        """ Recursive way to handle tree metadatas
-        """
-        for field in fieldset:
-            remove = self._should_remove(field)
-            if remove:
-                try:
-                    metadata[field.name] = field.value
-                except:
-                    metadata[field.name] = 'harmful content'
-            if remove is FIELD:
-                self._get_meta(field, None)
-
-    def _should_remove(self, key):
-        """ Return True if the field is compromising
-            abstract method
-        """
         raise NotImplementedError
 
     def create_backup_copy(self):