Anonymous avatar Anonymous committed a25f2a8

0.2pre5

Comments (0)

Files changed (6)

 
 Features added in this release:
 
-* 
+* Support for out of project modules for code completions and go to
+  definitions
+* Type inference of ``var = AClass()``
+* Renaming function parameters inside functions
+* Handling circular imports inside source files
+* Completeing ``AClass(params).a_``
+* Better quick outline view
 
-In the quick outline window you can use ``+`` and ``-`` to expand
-and collapse entries. Pressing ``Enter`` on an entry causes
-the cursor to go to the selected entry.
 
-If it is the first time you use rope, it might be helpful to try these:
+If an imported module can not found inside the project, the `sys.path`
+entries will be searched for it.
+
+If it is the first time you use rope, it might be helpful to try
+these:
 
 =============  ======================
 Alt-/          Show code assists
 Alt-Shift-r    Rename local variable
 =============  ======================
 
+If you want to change the font or keybindings edit
+`rope.editor.GraphicalEditor` class.
+
 
 Keybinding
 ==========
 Description
 ===========
 
-*rope* is a python IDE.  It tries to give users lots of things that
+*rope* is a python IDE. It tries to give users lots of things that
 are not available in python IDEs yet.
 
 Refactoring
 -----------
+
 In recent years refactoring has become a basic task of everyday
-programing, specially in java community.  In the agile programing
+programing, specially in java community. In the agile programing
 methodologies, like Extreme Programing, Refactoring is one of the core
 practices.
 
 Some IDEs support some basic refactorings like 'PyDev' (which uses
-bicycle repair man).  These IDEs have a limited set of refactorings
-and fail when doing refactorings that need to know the type of objects
-in the source code (specially for relatively large projects).  rope
-tries to provide a rich set of refactorings.  Some of the refactorings
+bicycle repair man). These IDEs have a limited set of refactorings and
+fail when doing refactorings that need to know the type of objects in
+the source code (specially for relatively large projects). rope tries
+to provide a rich set of refactorings. Some of the refactorings
 require type inference which is described later.
 
 Auto Completion
 ---------------
-One of the basic features of modern IDEs is the availability of
-auto-completion. Some Python IDEs have auto-completion support but in
-a limited form.  Since the type of many variables cannot be deduced
-from simple analysis of the source code. Auto-completing modules
-names, class names, static methods, class methods, function names and
-variable names are easy.  But auto-completing the methods and
-attributes of an object is hard.  Because the IDE needs to know the
+
+One of the basic features of modern IDEs is the availability of auto-
+completion. Some Python IDEs have auto-completion support but in a
+limited form. Since the type of many variables cannot be deduced from
+simple analysis of the source code. Auto-completing modules names,
+class names, static methods, class methods, function names and
+variable names are easy. But auto- completing the methods and
+attributes of an object is hard. Because the IDE needs to know the
 type of the object that cannot be achieved easily most of the time in
-dynamic languages.  rope will use Type Inference algorithms to solve
-this problem.
+dynamic languages. rope uses Type Inference algorithms to solve this
+problem.
 
 Type Inference
 --------------
+
 One disadvantage of dynamic languages like python is that you cannot
 know the type of variables by a simple analysis of program source code
-most of the time.  Knowing the type of variables is very essential for
-providing many of the refactorings and auto-completions.  rope will
-use type inference to overcome this problem.
+most of the time. Knowing the type of variables is very essential for
+providing many of the refactorings and auto-completions. rope will use
+type inference to overcome this problem.
 
 Static type inference uses program source code to guess the type of
-objects.  But type inference python programs is very hard.  There
-have been some attempts though not very successful (examples: psycho:
-only str and int types, StarKiller: wasn't released and ShedSkin: good
-but limited).  They where mostly directed at speeding up python
-programs by transforming its code to other typed languages rather than
-building IDEs.  Such algorithms might be helpful.
+objects. But it is is very hard. There have been some attempts though
+not very successful (examples: psycho: only str and int types,
+StarKiller: wasn't released and ShedSkin: good but limited). They
+where mostly directed at speeding up python programs by transforming
+its code to other typed languages rather than building IDEs. Such
+algorithms might be helpful.
 
-There is another approach toward type inference.  That is the
-analysis of running programs.  This dynamic approach records the types
-variables are assigned to during the program execution.  Although this
-approach is a lot easier to implement than the alternative, it is
-limited.  Only the parts of the program that are executed are
-analyzed.  If developers write unit tests and use test driven
-development this approach works very well.
+There is another approach toward type inference. That is the analysis
+of running programs. This dynamic approach records the types variables
+are assigned to during the program execution. Although this approach
+is a lot easier to implement than the alternative, it is limited. Only
+the parts of the program that are executed are analyzed. If developers
+write unit tests and use test driven development this approach works
+very well.
 
 
 Project Road Map
 ================
 
 The main motive for starting this project was the lack of good
-refactoring tools for python language.  Refactoring programs like
+refactoring tools for python language. Refactoring programs like
 "bicycle repair man" aren't reliable due to type inference problems
 discussed earlier and they support a limited number of refactorings.
 
-
 * Why an IDE and not a standalone library or program?
 
 As Don Roberts one of the writers of the "Refactoring Browser" for
 smalltalk writes in his doctoral thesis:
 
   "An early implementation of the Refactoring Browser for Smalltalk
-  was a separate tool from the standard Smalltalk development tools.
-  What we found was that no one used it.  We did not even use it
-  ourselves.  Once we integrated the refactorings directly into the
+  was a separate tool from the standard Smalltalk development
+  tools. What we found was that no one used it. We did not even use it
+  ourselves. Once we integrated the refactorings directly into the
   Smalltalk Browser, we used them extensively."
 
-The main goal of rope is to concentrate on type inference,
-auto-completion and refactoring of python programs and not a state of
-art IDE (At least not in the first phase).
-
-The type inference and refactoring parts of the rope will not be
-dependent on rope and if successful, will be released as standalone
-programs and libraries so that other projects may use them.
+The main goal of rope is to concentrate on the type inference and
+refactoring of python programs and not a state of art IDE (At least
+not in the first phase). The type inference and refactoring parts will
+not be dependent on rope and if successful, will be released as
+standalone programs and libraries so that other projects may use them.
 
 
 Get Involved!
 
 Rope has just started.  Right now rope's design changes rapidly and
 it's not yet ready for code contributions in its central parts.  I
-hope in soon future, somewhere about version 0.5 or 0.6, rope would be
+hope in soon future, somewhere about version 0.5, rope would be
 mature enough for being extended easily in those parts.
 
 Right now contributions are really needed in UI part and patches and
 =======
 
 This program is under the terms of GPL(GNU General Public License).
-Have a look at copying file for more information.
+Have a look at ``COPYING`` file for more information.
 
 ===========
 
 
+> Public Release 0.2pre5 : July 16, 2006
+
+
 - Out of project modules : July 15, 2006
 
 
   Writing ASTs
 
 
-> Public Release 0.2pre5 : July 16, 2006
-
-
 Remaining Stories
 -----------------
 * Change program goals and description; principles.txt

docs/tutorial.txt

 of its features.
 
 
-
 Starting Rope
 =============
 
 
 Use ``C-x C-k`` to close the active editor.
 
+
+Emacs Keybindings
+=================
+
+*rope* uses emacs keybindings most of the time. For example in most of
+the dialogs like ``code assist`` or ``outline`` you can use ``C-n``
+and ``C-p`` to move throw the items.
+
+Copying And Cutting
+-------------------
+
+Select the beginning of the region you want to copy or cut by moving
+the cursor on it and pressing ``Ctrl-space``.  Then move the cursor to
+the end of that region and use ``Alt-w`` or ``Ctrl-w`` for copying or
+cutting.
+
+For pasting move the cursor to the place you want to paste and press
+``Ctrl-y``.
+

docs/workingon.txt

 Pre-Release Refactorings
 ========================
 
-- Only looking in the holding scope range for renaming
-
 * Go to definition for packages should go to __init__.py; for FilteredPackages also
 * Eliminate FilteredPackage
 * Each PyPackage should have
   * The list of available children; derived from `__init__.py` or imports/froms
   * An import_name function that throws exception if the name cannot be found
 
-* Testing all in windows
-* Not viewing inherited names in outlines
-
 
 Before 0.2 Release
 ==================
 
 Remaining Stories
 =================
+* Not viewing inherited names in outlines
 * Optimize SourceLinesAdapter methods
 * Replace `rope.pycore._AttributeListFinder` with `rope.codeanalyze._StatementEvaluator`
 * More work on WordRangeFinder._get_statment_start; merging with StatementRangeFinder?
 
 
 class TextEditor(object):
-    '''The base class for all text editor'''
+    """The base class for all text editor"""
     def get_text(self):
         pass
     
 
 
 class TextIndex(object):
-    '''A class for pointing to a position in a text'''
+    """A class for pointing to a position in a text"""
 
 
 class LineEditor(object):
         current = str(self.text.index(INSERT))
         if self.text.get(current + '-1c') == '\n':
             return current + '-1c'
-        while self.text.compare(current, '!=', '1.0') and not self.text.get(current + ' -1c').isalnum():
+        while self.text.compare(current, '!=', '1.0') and \
+              not self.text.get(current + ' -1c').isalnum():
             current = str(self.text.index(current + ' -1c'))
             if self.text.get(current + '-1c') == '\n':
                 return current
         is_upper = self.text.get(current + ' -1c').isupper()
-        while self.text.compare(current, '!=', '1.0') and self.text.get(current + ' -1c').isalnum():
+        while self.text.compare(current, '!=', '1.0') and \
+              self.text.get(current + ' -1c').isalnum():
             current = str(self.text.index(current + ' -1c'))
             if  self.text.get(current).isupper():
                 break
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.