started the importing of modules + there is now a debug module

modules.py

@@ -0,0 +1,100 @@
+import imp
+import sys
+
+import debug
+import parsing
+
+files = {}
+load_module_cb = None
+module_find_path = sys.path[1:]
+
+
+class ModuleNotFound(Exception):
+    pass
+
+
+class File(object):
+    """
+    Manages all files, that are parsed and caches them.
+    If the source is not given, it is loaded by load_module.
+
+    :param source: The source code of the file.
+    :param module_name: The module name of the file.
+    """
+    def __init__(self, module_name, source=None):
+        self.source = source
+        self.module_name = module_name
+        self._line_cache = None
+        self._parser = None
+
+    @property
+    def parser(self):
+        if self._parser:
+            return self._parser
+        if not self.module_name and not self.source:
+            raise AttributeError("Submit a module name or the source code")
+        elif self.module_name:
+            return self.load_module()
+
+    def load_module(self):
+        if not self.source:
+            if i[0]:  # is the file pointer
+                self.source = open(i[0]).read()
+                print self.source, 'yesssa'
+            else:
+                self.source = ''
+                print 'shizzel'
+        self._parser = parsing.PyFuzzyParser(self.source)
+        return self._parser
+
+    def get_line(self, line):
+        if not self._line_cache:
+            self._line_cache = self.source.split('\n')
+
+        if 1 <= line <= len(self._line_cache):
+            return self._line_cache[line - 1]
+        else:
+            return None
+
+
+def follow_module(_import):
+    """
+    follows a module name and returns the parser.
+    :param name: A name from the parser.
+    :type name: parsing.Name
+    """
+    def follow_str(ns, string):
+        print ns, string
+        if ns:
+            path = ns[1]
+        else:
+            path = module_find_path
+            debug.dbg('search_module', string, path)
+        i = imp.find_module(string, path)
+        return i
+
+    # set path together
+    ns_list = []
+    if _import.from_ns:
+        ns_list += _import.from_ns.names
+    if _import.namespace:
+        ns_list += _import.namespace.names
+
+    # now execute those paths
+    current_namespace = None
+    rest = None
+    for i, s in enumerate(ns_list):
+        try:
+            current_namespace = follow_str(current_namespace, s)
+        except ImportError:
+            if current_namespace:
+                rest = ns_list[i:]
+            else:
+                raise ModuleNotFound(
+                        'The module you searched has not been found')
+
+    print 'yay', current_namespace
+    f = File(current_namespace[2], current_namespace[0].read())
+    out = f.parser.top.get_names()
+    print out
+    return parser