1 files changed, 71 insertions, 43 deletions

diff --git a/dodai/config/files.py b/dodai/config/files.py
index 3ca9121..a27e4a2 100644
--- a/dodai/config/files.py
+++ b/dodai/config/files.py
@@ -17,62 +17,90 @@
 
 import os
 import ConfigParser
-from dodai.tools.himo import String2Himo
 from dodai.config.sections import ConfigSections
+from dodai.exception import InvalidConfigParser
+from dodai.exception import FileDoesNotExist
+from dodai.exception import FileIsDirectory
 
 class ConfigFiles(object):
 
-    def __init__(self):
+    REQUIRED_METHODS = ['read', 'sections', 'options', 'get']
 
-        self._default_parser = ConfigParser.ConfigParser()
-        self._string_object = String2Himo()
-        self._files = {}
+    def __init__(self, ordered_dict_object, section_object, string_object):
 
-    def set_default_parser(self, parser):
-        self.check_config_parser(parser)
-        self._default_parser = parser
+        self._ordered_dict_object = ordered_dict_object
+        self._section_object = section_object
+        self._string_object = string_object
+        self.parser_objects = []
+        self.files = self._ordered_dict_object()
+        self.files_read = []
 
-    def set_string_object(self, obj):
-        self._string_object = obj
+    def register_parser_object(self, parser_object):
+        """Registers a config file parser with this object.  Raises
+        InvalidConfigParser error if the parser does not have the 'read',
+        'sections', 'options' and 'get' methods.
 
-    def add(self, path, encoding=None, parser=None):
-        if parser:
-            self.check_config_parser(parser)
-        if os.path.exists(path):
-            if parser:
-                self._files[path] = [parser, encoding]
+        """
+        if self.check_parser_object(parser_object):
+            self.parser_objects.append(parser_object)
+
+    def check_parser_object(self, parser_object):
+        """Checks the given parser object to insure it has all of the required
+        methods needed to parse files.
+
+        """
+        for name in self.REQUIRED_METHODS:
+            if not hasattr(parser_object, name):
+                raise InvalidConfigParser(self.REQUIRED_METHODS,
+                                          parser_object.__name__)
+        return True
+
+    def add(self, filename, encoding=None):
+        """Adds the given filename to this object to be parsed.
+
+        """
+        if os.path.exists(filename):
+            if os.path.isdir(filename):
+                raise FileIsDirectory(filename)
             else:
-                self._files[path] = [self._default_parser, encoding]
+                filename = os.path.realpath(filename)
+                self.files[filename] = encoding
         else:
-            raise FileDoesNotExist(path)
+            raise FileDoesNotExist(filename)
 
-    def is_valid_config_parser(self, obj):
-        out = True
-        if not hasattr(obj, 'read'):
-            out = False
+    def _read(self):
+        self.files_read = []
+        out = self._ordered_dict_object()
+        for filename, encoding in self.files.items():
+            error = False
+            for parser_obj in self.parser_objects:
+                try:
+                    parser = parser_obj()
+                    parser.read(filename)
+                except Exception, e:
+                    error = True
+                else:
+                    out[filename] = self._ordered_dict_object()
+                    out[filename]['encoding'] = encoding
+                    out[filename]['parser'] = parser
+                    self.files_read.append(filename)
+                    error = False
+                    break
+            if error:
+                raise e
         return out
 
-    def check_config_parser(self, obj):
-        if self.is_valid_config_parser(obj):
-            return True
-        else:
-            raise InvalidConfigParser("Please make sure your object "\
-                                      "has the following methods: "\
-                                      "sections, options, read and get.")
 
-    def load(self, sections_object=None):
-        paths = []
-        sections = sections_object or ConfigSections(self._string_object)
-        for path, data in self._files.items():
-            parser = data[0]
-            encoding = data[1]
-            parser.read(path)
+    def load(self):
+        """Returns a ConfigSections object, which acts like a dictionary,
+        that contains all parsed data.
+
+        """
+        files = self._read()
+        sections = ConfigSections(self._ordered_dict_object,
+                                  self._section_object, self._string_object)
+        for filename, data in files.items():
+            encoding = data['encoding']
+            parser = data['parser']
             sections(parser, encoding)
         return sections
-
-
-class InvalidConfigParser(Exception):
-    pass
-
-class FileDoesNotExist(Exception):
-    pass