The current version is (mostly) working

19 files changed, 290 insertions, 153 deletions

diff --git a/README b/README
deleted file mode 100644
index e69de29..0000000
--- a/README
+++ /dev/null
diff --git a/clean.jpg b/clean.jpg
new file mode 100644
index 0000000..09c9161
--- /dev/null
+++ b/clean.jpg
diff --git a/cli.py b/cli.py
index d249917..fedb40c 100644
--- a/cli.py
+++ b/cli.py
@@ -3,7 +3,82 @@
     Metadata anonymisation toolkit
 """
 
-import lib
 import sys
+import mat
+import argparse
 
+__version__ = "0.1"
 
+def parsing():
+    '''
+        Parse the arguments,
+        and returns a dict
+    '''
+    parser = argparse.ArgumentParser(version=__version__,
+        description="Metadata Anonymisation Toolkit - CLI %s" % __version__)
+
+    #list and check clean are mutually exclusives
+    group = parser.add_mutually_exclusive_group()
+
+    #list meta
+    group.add_argument('--print-meta', '-p', action="store_true", default=False,
+        dest='just_list', help='List all the meta of a file,\
+        without removing them')
+
+    #check if the file is clean
+    group.add_argument('--check-clean', '-c', action="store_true",
+        default=False, dest='just_check',
+        help='Check if a file is clean of harmfull metadatas')
+
+    #list of files to process
+    parser.add_argument('filelist', action="store", type=str, nargs="+",
+        metavar='file', help='File(s) to process')
+
+    return parser.parse_args()
+
+def list_meta(class_file, filename):
+    '''
+        Print all the meta of "filename" on stdout
+    '''
+    print("[+] File %s :" % filename)
+    for key, item in class_file.get_meta().iteritems():
+        print("\t%s : %s" % (key, item) )
+
+def is_clean(class_file, filename):
+    '''
+        Say if "filename" is clean or not
+    '''
+    if class_file.is_clean():
+        print("[+] %s is clean" % filename)
+    else:
+        print("[+] %s is not clean" % filename)
+
+def clean_meta(class_file, filename):
+    '''
+        Clean the file "filename"
+    '''
+    print("[+] Cleaning %s" % filename)
+    if class_file.is_clean():
+        print("%s is already clean" % filename)
+    else:
+        class_file.remove_all()
+        print("%s cleaned !" % filename)
+
+def main():
+    args = parsing()
+
+    #func receive the function correponding to the options given as parameters
+    if args.just_list is True: #only print metadatas
+        func = list_meta
+    elif args.just_check is True: #only check if the file is clean
+        func = is_clean
+    else: #clean the file
+        func = clean_meta
+
+    for filename in args.filelist:
+        class_file = mat.create_class_file(filename)
+        func(class_file, filename)
+        print("\n")
+
+if __name__ == '__main__':
+    main()
diff --git a/lib/test.py b/clitest.py
index b1ff2a3..00955ae 100644
--- a/lib/test.py
+++ b/clitest.py
@@ -1,45 +1,29 @@
-import mat
+import cli
 import unittest
-import shutil
-import glob
-import tempfile
+import test
 
-FILE_LIST = zip(glob.glob('clean*'), glob.glob('dirty*'))
+import shlex
+import subprocess
 
-class MATTest(unittest.TestCase):
-    def setUp(self):
-        '''create working copy of the clean and the dirty file in the TMP dir'''
-        self.file_list = []
-        self.tmpdir = tempfile.mkdtemp()
-
-        for clean, dirty in FILE_LIST:
-            shutil.copy2(clean, self.tmpdir + clean)
-            shutil.copy2(dirty, self.tmpdir + dirty)
-            self.file_list.append((self.tmpdir + clean, self.tmpdir + dirty))
-
-    def tearDown(self):
-        '''Remove the tmp folder'''
-        shutil.rmtree(self.tmpdir)
-
-class Test_Remove(MATTest):
+class Test_Remove_cli(test.MATTest):
     def test_remove(self):
-        '''make sure that the lib remove all compromizing meta'''
+        '''make sure that the cli remove all compromizing meta'''
         for clean, dirty in self.file_list:
-            mat.file(dirty).remove_all()
+            subprocess.call("cli.py %s" dirty)
             self.assertTrue(mat.file(dirty).is_clean())
 
     def test_remove_empty(self):
         '''Test removal with clean files'''
         for clean, dirty in self.file_list:
-            mat.file(clean).remove_all()
-            self.assertTrue(mat.file(clean).is_clean())
+            subprocess.call("cli.py %s" clean)
+            self.assertTrue(mat.file(dirty).is_clean())
 
 
-class Test_List(MATTest):
+class Test_List_cli(test.MATTest):
     def test_list(self):
         '''check if get_meta returns all the expected meta'''
         for clean, dirty in self.file_list:
-            meta_list = dict() #FIXME
+            meta_list = dict("fixme":"please",) #FIXME
             self.assertDictEqual(mat.file(dirty).get_meta(), meta_list)
 
     def testlist_list_empty(self):
@@ -48,7 +32,7 @@ class Test_List(MATTest):
             self.assertEqual(mat.file(clean).get_meta(), None)
 
 
-class Test_isClean(MATTest):
+class Test_isClean_cli(test.MATTest):
     def test_clean(self):
         '''test is_clean on clean files'''
         for clean, dirty in self.file_list:
diff --git a/dirty.jpg b/dirty.jpg
new file mode 100644
index 0000000..09c9161
--- /dev/null
+++ b/dirty.jpg
diff --git a/lib/hachoir_editor/__init__.py b/hachoir_editor/__init__.py
index b106278..b106278 100644
--- a/lib/hachoir_editor/__init__.py
+++ b/hachoir_editor/__init__.py
diff --git a/hachoir_editor/__init__.pyc b/hachoir_editor/__init__.pyc
new file mode 100644
index 0000000..23f4a8e
--- /dev/null
+++ b/hachoir_editor/__init__.pyc
diff --git a/lib/hachoir_editor/field.py b/hachoir_editor/field.py
index 6b1efe3..6b1efe3 100644
--- a/lib/hachoir_editor/field.py
+++ b/hachoir_editor/field.py
diff --git a/hachoir_editor/field.pyc b/hachoir_editor/field.pyc
new file mode 100644
index 0000000..ff7b91d
--- /dev/null
+++ b/hachoir_editor/field.pyc
diff --git a/lib/hachoir_editor/fieldset.py b/hachoir_editor/fieldset.py
index 1669b5a..1669b5a 100644
--- a/lib/hachoir_editor/fieldset.py
+++ b/hachoir_editor/fieldset.py
diff --git a/hachoir_editor/fieldset.pyc b/hachoir_editor/fieldset.pyc
new file mode 100644
index 0000000..f4e37fa
--- /dev/null
+++ b/hachoir_editor/fieldset.pyc
diff --git a/lib/hachoir_editor/typed_field.py b/hachoir_editor/typed_field.py
index 4abc989..4abc989 100644
--- a/lib/hachoir_editor/typed_field.py
+++ b/hachoir_editor/typed_field.py
diff --git a/hachoir_editor/typed_field.pyc b/hachoir_editor/typed_field.pyc
new file mode 100644
index 0000000..3d442ed
--- /dev/null
+++ b/hachoir_editor/typed_field.pyc
diff --git a/lib/check/images/jpg.py b/lib/check/images/jpg.py
deleted file mode 100644
index 7f29587..0000000
--- a/lib/check/images/jpg.py
+++ /dev/null
@@ -1,17 +0,0 @@
-import hachoir_core.error
-import hachoir_core.cmd_line
-import hachoir_parser
-import hachoir_metadata
-import sys
-import mat
-
-
-class JpegStripper(file):
-    def checkField(self, field):
-            print(field.description)
-            if field.name.startswith("comment"):
-                return True
-            return field.name in ("photoshop", "exif", "adobe")
-        return False
-
-
diff --git a/lib/mat.py b/lib/mat.py
deleted file mode 100644
index d22c9ab..0000000
--- a/lib/mat.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import hachoir_core.error
-import hachoir_core.cmd_line
-import hachoir_parser
-import hachoir_metadata
-
-from strippers import *
-
-from hachoir_editor import (createEditor,
-    NewFieldSet, EditableInteger, EditableBytes)
-
-import hachoir_editor
-
-import sys
-
-__version__ = "0.1"
-__author__ = "jvoisin"
-
-
-class file():
-    def __init__(self, filename):
-        self.metadata = {}
-        self.clean = False
-        self.editor = createEditor(self.parser)
-        self.filename = filename
-        self.filename, self.realname = hachoir_core.cmd_line.unicodeFilename(
-            self.filename), self.filename
-        self.parser = hachoir_parser.createParser(self.filename, self.realname)
-
-        if not self.parser:
-            print("Unable to parse file : sorry")
-            sys.exit(1)
-
-        try:
-            self.meta = hachoir_metadata.extractMetadata(self.parser)
-        except hachoir_core.error.HachoirError, err:
-            print "Metadata extraction error: %s" % unicode(err)
-            self.data = None
-
-        if not self.meta:
-            print "Unable to extract metadata"
-            sys.exit(1)
-
-    def is_clean(self):
-        '''
-            Return true if the file is clean from any compromizing meta
-        '''
-        return self.clean
-
-    def remove_all(self):
-        '''
-            Remove all the files that are compromizing
-        '''
-        stripEditor(self.editor, self.realname, level, not(values.quiet))
-        for key, field in metadata:
-            if should_remove(key):
-                remove(self, key)
-
-    def remove(self, field):
-        '''
-            Remove the given file
-        '''
-        del editor[field]
-        return True
-
-
-    def get_meta(self):
-        '''return a dict with all the meta of the file'''
-        #FIXME : sooooooooooo dirty !
-        for title in self.meta:
-            if title.values != []: #if the field is not empty
-                value = ""
-                for item in title.values:
-                    value = item.text
-                self.metadata[title.key] = value
-        return self.metadata
-
-    def should_remove(self, field):
-        '''
-            return True if the field is compromizing
-            abstract method
-        '''
-        raise NotImplementedError()
-
-def stripEditor(editor, filename, realname, level, verbose):
-    '''
-        Assign a stripper to an editor
-    '''
-    cls = editor.input.__class__
-    try:
-        stripper_cls = strippers[cls]
-    except KeyError:
-        print "Don't have stripper for file type: %s" % editor.description
-        return False
-    stripper = stripper_cls(editor, level, verbose)
-
-    if stripper():
-        output = FileOutputStream(filename, realname)
-        editor.writeInto(output)
-
-    else:
-        print _("Stripper doesn't touch the file")
-    return True
-
-file(sys.argv[1]).get_meta()
diff --git a/lib/strippers.py b/lib/strippers.py
deleted file mode 100644
index 70d0fc7..0000000
--- a/lib/strippers.py
+++ /dev/null
@@ -1,3 +0,0 @@
-strippers = {
-    JpegFile: JpegStripper,
-}
diff --git a/libtest.py b/libtest.py
new file mode 100644
index 0000000..191a981
--- /dev/null
+++ b/libtest.py
@@ -0,0 +1,56 @@
+import mat
+import unittest
+import test
+
+class Test_Remove_lib(test.MATTest):
+    def test_remove(self):
+        '''make sure that the lib remove all compromizing meta'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(dirty)
+            current_file.remove_all()
+            self.assertTrue(current_file.is_clean())
+
+    def test_remove_empty(self):
+        '''Test removal with clean files'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(clean)
+            current_file.remove_all()
+            self.assertTrue(current_file.is_clean())
+
+
+class Test_List_lib(test.MATTest):
+    def test_list(self):
+        '''check if get_meta returns all the expected meta'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(dirty)
+            meta_list = dict({"fixme":"please"},)
+            self.assertDictEqual(current_file.get_meta(), meta_list)
+
+    def testlist_list_empty(self):
+        '''check that a listing of a clean file return an empty dict'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(clean)
+            self.assertEqual(current_file.get_meta(), dict()) #dirty, isn't it ?
+
+
+class Test_isClean_lib(test.MATTest):
+    def test_clean(self):
+        '''test is_clean on clean files'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(dirty)
+            self.assertTrue(current_file.is_clean())
+
+    def test_clean(self):
+        '''test is_clean on dirty files'''
+        for clean, dirty in self.file_list:
+            current_file = mat.create_class_file(clean)
+            self.assertFalse(current_file.is_clean())
+
+
+if __name__ == '__main__':
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(Test_Remove_lib))
+    suite.addTest(unittest.makeSuite(Test_List_lib))
+    suite.addTest(unittest.makeSuite(Test_isClean_lib))
+    unittest.TextTestRunner(verbosity=2).run(suite)
+
diff --git a/mat.py b/mat.py
new file mode 100644
index 0000000..8a3afcd
--- /dev/null
+++ b/mat.py
@@ -0,0 +1,117 @@
+import hachoir_core.error
+import hachoir_core.cmd_line
+import hachoir_parser
+import hachoir_metadata
+import hachoir_editor
+
+import sys
+import os
+import hachoir_parser.image
+
+__version__ = "0.1"
+__author__ = "jvoisin"
+
+
+class file():
+    def __init__(self, realname, filename, parser, editor):
+        self.meta = {}
+        self.clean = False
+        self.filename = filename
+        self.realname = realname
+        self.parser = parser
+        self.editor = editor
+        self.meta = self.__fill_meta()
+
+    def __fill_meta(self):
+        metadata = {}
+        try:
+            meta = hachoir_metadata.extractMetadata(self.parser)
+        except hachoir_core.error.HachoirError, err:
+            print("Metadata extraction error: %s" % err)
+
+        if not meta:
+            print("Unable to extract metadata from the file %s" % self.filename)
+            sys.exit(1)
+
+        for title in meta:
+            #fixme i'm so dirty
+            if title.values != []: #if the field is not empty
+                value = ""
+                for item in title.values:
+                    value = item.text
+                metadata[title.key] = value
+        return metadata
+
+    def is_clean(self):
+        '''
+            Return true if the file is clean from any compromizing meta
+        '''
+        return self.clean
+
+    def remove_all(self):
+        '''
+            Remove all the files that are compromizing
+        '''
+        for key, field in self.meta.iteritems():
+            if self._should_remove(key):
+                print "BLEH" #DEBUG
+                #__remove(self, key)
+        #self.clean = True
+
+    def __remove(self, field):
+        '''
+            Remove the given file
+        '''
+        del self.editor[field]
+
+
+    def get_meta(self):
+        '''
+            return a dict with all the meta of the file
+        '''
+        return self.meta
+
+    def _should_remove(self, field):
+        '''
+            return True if the field is compromizing
+            abstract method
+        '''
+        raise NotImplementedError()
+
+class JpegStripper(file):
+    def _should_remove(self, field):
+        return False
+
+strippers = {
+    hachoir_parser.image.JpegFile: JpegStripper,
+}
+
+def create_class_file(name):
+    '''
+        return a $FILETYPEStripper() class,
+        corresponding to the filetype of the given file
+    '''
+    if not(os.path.isfile(name)): #check if the file exist
+        print("Error: %s is not a valid file" % name)
+        sys.exit(1)
+
+    filename = ""
+    realname = name
+    filename = hachoir_core.cmd_line.unicodeFilename(name)
+    parser = hachoir_parser.createParser(filename, realname)
+    if not parser:
+        print("Unable to parse the file %s : sorry" % filename)
+        sys.exit(1)
+
+    editor = hachoir_editor.createEditor(parser)
+    try:
+        '''this part is a little tricky :
+        stripper_class will receice the name of the class $FILETYPEStripper,
+        (which herits from the "file" class), based on the editor
+        of given file (name)
+        '''
+        stripper_class = strippers[editor.input.__class__]
+    except KeyError:
+        print("Don't have stripper for file type: %s" % editor.description)
+        sys.exit(1)
+    return stripper_class(realname, filename, parser, editor)
diff --git a/test.py b/test.py
new file mode 100644
index 0000000..3138be7
--- /dev/null
+++ b/test.py
@@ -0,0 +1,29 @@
+'''
+    Class for the testing suite :
+        - get the list of all test files
+        - create a copy of them on start
+        - remove the copy on end
+'''
+
+import shutil
+import glob
+import tempfile
+import unittest
+import mat
+
+FILE_LIST = zip(glob.glob('clean*'), glob.glob('dirty*'))
+
+class MATTest(unittest.TestCase):
+    def setUp(self):
+        '''create working copy of the clean and the dirty file in the TMP dir'''
+        self.file_list = []
+        self.tmpdir = tempfile.mkdtemp()
+
+        for clean, dirty in FILE_LIST:
+            shutil.copy2(clean, self.tmpdir + clean)
+            shutil.copy2(dirty, self.tmpdir + dirty)
+            self.file_list.append((self.tmpdir + clean, self.tmpdir + dirty))
+
+    def tearDown(self):
+        '''Remove the tmp folder'''
+        shutil.rmtree(self.tmpdir)