correct developer documentation a little bit

docs/docs/development.rst

@@ -149,15 +149,15 @@ Fast Parser (parser/fast.py)
 
 .. _docstrings:
 
-Docstrings (docstrings.py)
+Docstrings (evaluate/docstrings.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.evaluate.docstrings
 
 .. _refactoring:
 
-Refactoring (refactoring.py)
+Refactoring (evaluate/refactoring.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.refactoring
 
@@ -175,25 +175,24 @@ Imports & Modules
 
 .. _builtin:
 
-Compiled Modules (compiled.py)
+Compiled Modules (evaluate/compiled.py)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.evaluate.compiled
 
+
 .. _imports:
 
-
+Imports (evaluate/imports.py)
-Imports (imports.py)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-~~~~~~~~~~~~~~~~~~~~
 
 .. automodule:: jedi.evaluate.imports
 
 
-
 .. _caching-recursions:
 
 Caching & Recursions
-----------------------
+--------------------
 
 
 - :ref:`Caching <cache>`
@@ -214,16 +213,14 @@ Recursions (recursion.py)
 .. automodule:: jedi.evaluate.recursion
 
 
-
 .. _dev-helpers:
 
 Helper Modules
 ---------------
 
-There are some helper modules: `common.py`, `helpers.py`, `debug.py`,
+Most other modules are not really central to how Jedi works. They all contain
-`keywords.py`, which I won't describe further. Some functions are inheritely
+relevant code, but you if you understand the modules above, you pretty much
-important and central for Jedi to work, but not important to understand how
+understand Jedi.
-Jedi works.
 
 Python 2/3 compatibility (_compatibility.py)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

jedi/evaluate/__init__.py

@@ -1,8 +1,8 @@
 """
 Evaluation of Python code in |jedi| is based on three assumptions:
 
-* Code is recursive (to weaken this assumption, the :mod:`dynamic` module
+* Code is recursive (to weaken this assumption, the
-  exists).
+  :mod:`jedi.evaluate.dynamic` module exists).
 * No magic is being used:
 
   - metaclasses
@@ -37,7 +37,7 @@ This is exactly where it starts to get complicated. Now recursions start to
 kick in. The statement has not been resolved fully, but now we need to resolve
 the datetime import. So it continues
 
-- follow import, which happens in the :mod:`imports` module.
+- follow import, which happens in the :mod:`jedi.evaluate.imports` module.
 - now the same ``eval_call`` as above calls ``follow_path`` to follow the
   second part of the statement ``date``.
 - After ``follow_path`` returns with the desired ``datetime.date`` class, the

jedi/evaluate/docstrings.py

@@ -1,8 +1,8 @@
 """
 Docstrings are another source of information for functions and classes.
-:mod:`dynamic` tries to find all executions of functions, while the docstring
+:mod:`jedi.evaluate.dynamic` tries to find all executions of functions, while
-parsing is much easier. There are two different types of docstrings that |jedi|
+the docstring parsing is much easier. There are two different types of
-understands:
+docstrings that |jedi| understands:
 
 - `Sphinx <http://sphinx-doc.org/markup/desc.html#info-field-lists>`_
 - `Epydoc <http://epydoc.sourceforge.net/manual-fields.html>`_

jedi/evaluate/representation.py

@@ -1,6 +1,7 @@
 """
-Like described in the :mod:`parsing_representation` module, there's a need for
+Like described in the :mod:`jedi.evaluate.parsing_representation` module,
-an ast like module to represent the states of parsed modules.
+there's a need for an ast like module to represent the states of parsed
+modules.
 
 But now there are also structures in Python that need a little bit more than
 that. An ``Instance`` for example is only a ``Class`` before it is