Anonymous avatar Anonymous committed 3939c66

0.2pre

Comments (0)

Files changed (11)

-                         rope : A Python IDE
+rope, A python IDE
 
 Overview
 --------
 
 Version Overview
 ----------------
+Features added in this release:
+  * Auto complete global variables
+  * Auto complete class and function names
+  * Showing searching status in status bar
+  * Auto complete imported modules
+  * Auto complete keywords and builtins
+
+In this release some basic auto-completion support was added.
 
 
 Keybinding
 C-space        set mark
 C-w            cut region
 M-w            copy region
+C-x C-x        swap mark and insert
 C-y            paste
 C-x C-s        save
 C-i            correct line indentation
 
 Description
 -----------
-
   This program, rope, is a python IDE. It tries to give users lots of things
 that are not available in python IDEs yet.
 
 
 Project Road Map
 ----------------
-
   The main motive for starting this project was the lack of good
 refactoring tools for python language. Refactoring programs like "bicycle repair man"
 aren't reliable due to type inferencing problems discussed earlier and they
 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 inferencing and refactoring
-of python programs and not a state of art IDE (At least not in the first phase).
-The type inferencing and refactoring parts of the rope will not
+  The main goal of rope is to concentrate on type inferencing, auto-completion
+and refactoring of python programs and not a state of art IDE (At least not in
+the first phase).
+
+  The type inferencing and refactoring parts of the rope will not
 dependent on rope and if successful, will be released as standalone programs
 and libraries so that other projects may use them.
 
 
-Bug reports
+Get Involved!
+-------------
+  Rope has just started. Right now rope's design changes rapidly and it's not
+yet ready for code contributions. I hope in soon future, somewhere around version
+0.5 or 0.6, rope would be mature enough for being extended easily.
+
+  Anyway right now contributions are really needed in many places. For example
+patches and extensions in the UI part are extremely welcome. Have a look at the
+UI enhancement stories(docs/stories.txt). Send your patches in sourceforge.net
+project page, http://sf.net/projects/rope. Patches should use python coding
+style, PEP 8, and should have good unit tests. rope uses a local repository
+right now, but it will be moved to SVN repository on sourceforge.net some time
+before the 0.3 release. If you're making your patches using source package
+distributions specify the version of that package.
+
+
+Bug Reports
 -----------
-  Send your bug reports and feature requests to rope's sourceforge
+  Send your bug reports and feature requests to rope's sourceforge.net
 project page at http://sf.net/projects/rope.
 
 
 * Variable indentation and tab size @ 1
 
 
+* Find occurances @ 5
+
+
 * Open Type @ 2
 
 
 
 
 * Enhancing auto-completion @ 2
-  * What if the statement in current line is spread in more than one line
   * Complete as you type (updating proposal list while typing)
   * What to do when the program has syntax errors
+  * Sorting proposals
+
+
+* Auto completing and comments and strings @ 1
+
+
+* Auto-completion should ignore current statement @ 1
+  What if the statement in current line is spread in more than one line.
 
 
 * Auto-complete local variable names @ 3
 ? Change program goals and description; principles.html
   ? Go toward refactoring and ... library rather than an IDE
 ? roadmap.html
-? Migrating to sourceforge SVN before 0.2 release
-    ? SF repository; SVN or CVS? How to synchronize local SVN with SF?
+? Migrating to sourceforge SVN before 0.3 release
+  ? SF repository; SVN or CVS? How to synchronize local SVN with SF?
 ? Should workingon.txt be under version control?
 ? Functional tests
 ? Separate domain and presentation everywhere
+* Logo
 * Make tests less dependant
 ? Project resource consistency; What if it is deleted after being created.

docs/workingon.txt

 - Setting better font for status bar
 - Not auto completing only the words after dot
 
-? What to do after dots?
 ? Sorting the proposals
 ? Completions are context dependant
 
         self.status_bar = Frame(self.main, borderwidth=1, relief=RIDGE)
         self.status_bar_manager = rope.statusbar.StatusBarManager(self.status_bar)
         line_status = self.status_bar_manager.create_status('line')
-        line_status.set_width(20)
+        line_status.set_width(12)
 
         self._set_key_binding(self.root)
         self.root.protocol('WM_DELETE_WINDOW', self.exit)

rope/searching.py

         self.status_text = None
         if self.editor.status_bar_manager:
             self.status_text = self.editor.status_bar_manager.create_status('search')
-            self.status_text.set_width(25)
+            self.status_text.set_width(33)
         self.update_status_text()
 
     def _finish_searching(self):

rope/statusbar.py

     def remove_status(self, status):
         status.label.destroy()
         del self.status_text[status.kind]
+

ropetest/coretest.py

         unittest.TestCase.setUp(self)
         Core.get_core().close_project()
         self.projectMaker = SampleProjectMaker()
-        self.fileName = self.projectMaker.getSampleFileName()
+        self.fileName = self.projectMaker.get_sample_file_name()
         self.fileName2 = 'samplefile2.txt'
         file_ = open(self.fileName, 'w')
         file_.write('sample text')
         file_.close()
-        Core.get_core().open_project(self.projectMaker.getRoot())
+        Core.get_core().open_project(self.projectMaker.get_root())
         self.textEditor = Core.get_core().open_file(self.fileName)
         self.project = Core.get_core().get_open_project()
 
     def tearDown(self):
-        self.projectMaker.removeAll()
+        self.projectMaker.remove_all()
         os.remove(self.fileName)
         if os.path.exists(self.fileName2):
             os.remove(self.fileName2)
         unittest.TestCase.tearDown(self)
 
     def test_opening_files(self):
-        self.assertEquals(self.projectMaker.getSampleFileContents(), self.textEditor.get_editor().get_text())
+        self.assertEquals(self.projectMaker.get_sample_file_contents(),
+                          self.textEditor.get_editor().get_text())
 
     def test_active_editor(self):
         self.assertEquals(self.textEditor, Core.get_core().get_active_editor())
         self.assertEquals('run', self.project.get_resource('output.txt').read())
 
     def test_not_reopening_editors(self):
-        editor1 = Core.get_core().open_file(self.projectMaker.getSampleFileName())
-        editor2 = Core.get_core().open_file(self.projectMaker.getSampleFileName())
+        editor1 = Core.get_core().open_file(self.projectMaker.get_sample_file_name())
+        editor2 = Core.get_core().open_file(self.projectMaker.get_sample_file_name())
         self.assertTrue(editor1 is editor2)
     
     def test_closing_editor(self):
-        editor = Core.get_core().open_file(self.projectMaker.getSampleFileName())
+        editor = Core.get_core().open_file(self.projectMaker.get_sample_file_name())
         self.assertEquals(Core.get_core().get_active_editor(), editor)
         Core.get_core().close_active_editor()
         self.assertNotEquals(Core.get_core().get_active_editor(), editor)

ropetest/fileeditortest.py

         unittest.TestCase.setUp(self)
         self.text = MockEditor()
         self.projectMaker = SampleProjectMaker()
-        self.fileName = self.projectMaker.getSampleFileName()
-        self.project = Project(self.projectMaker.getRoot())
+        self.fileName = self.projectMaker.get_sample_file_name()
+        self.project = Project(self.projectMaker.get_root())
         self.editor = FileEditor(self.project, self.project.get_resource(self.fileName), self.text)
     
     def tearDown(self):
-        self.projectMaker.removeAll()
+        self.projectMaker.remove_all()
         unittest.TestCase.tearDown(self)
         
-    def testCreation(self):
-        self.assertEquals(self.projectMaker.getSampleFileContents(),
+    def test_creation(self):
+        self.assertEquals(self.projectMaker.get_sample_file_contents(),
                           self.editor.get_editor().get_text())
 
-    def testSaving(self):
+    def test_saving(self):
         self.text.set_text('another text')
         self.editor.save()
         self.assertEquals('another text', self.project.get_resource(self.fileName).read())

ropetest/indentertest.py

 
     # TODO: handle this case
     def xxx_test_deindenting_after_implicit_continuation_after_return(self):
-        self.editor.set_text('def f():\n    return (2,\n3)\na = 10')
+        self.editor.set_text('def f():\n    return (2,\n            3)\na = 10')
         self.indenter.correct_indentation(self.editor.get_end())
-        self.assertEquals('def f():\n    return (2,\n            3)\na = 10', self.editor.get_text())
+        self.assertEquals('def f():\n    return (2,\n            3)\na = 10',
+                          self.editor.get_text())
 
     def test_deindenting_empty_lines(self):
         self.editor.set_text('\n')

ropetest/projecttest.py

         sample.write('sample text\n')
         sample.close()
 
-    def getRoot(self):
+    def get_root(self):
         return self.projectRoot
 
-    def getSampleFileName(self):
+    def get_sample_file_name(self):
         return self.sampleFile
 
-    def getSampleFolderName(self):
+    def get_sample_folder_name(self):
         return self.sampleFolder
 
-    def getSampleFileContents(self):
+    def get_sample_file_contents(self):
         return 'sample text\n'
 
-    def removeAll(self):
-        SampleProjectMaker.removeRecursively(self.projectRoot)
+    def remove_all(self):
+        SampleProjectMaker.remove_recursively(self.projectRoot)
 
     @staticmethod
-    def removeRecursively(file):
+    def remove_recursively(file):
         for root, dirs, files in os.walk(file, topdown=False):
             for name in files:
                 os.remove(os.path.join(root, name))
     def setUp(self):
         unittest.TestCase.setUp(self)
         self.projectMaker = SampleProjectMaker()
-        self.project = Project(self.projectMaker.getRoot())
+        self.project = Project(self.projectMaker.get_root())
 
     def tearDown(self):
-        self.projectMaker.removeAll()
+        self.projectMaker.remove_all()
         unittest.TestCase.tearDown(self)
 
-    def testProjectCreation(self):
-        self.assertEquals(self.projectMaker.getRoot(), self.project.get_root_address())
+    def test_project_creation(self):
+        self.assertEquals(self.projectMaker.get_root(), self.project.get_root_address())
 
-    def testGettingProjectFile(self):
-        projectFile = self.project.get_resource(self.projectMaker.getSampleFileName())
+    def test_getting_project_file(self):
+        projectFile = self.project.get_resource(self.projectMaker.get_sample_file_name())
         self.assertTrue(projectFile is not None)
 
-    def testProjectFileReading(self):
-        projectFile = self.project.get_resource(self.projectMaker.getSampleFileName())
-        self.assertEquals(self.projectMaker.getSampleFileContents(), projectFile.read())
+    def test_project_file_reading(self):
+        projectFile = self.project.get_resource(self.projectMaker.get_sample_file_name())
+        self.assertEquals(self.projectMaker.get_sample_file_contents(), projectFile.read())
     
-    def testGettingNotExistingProjectFile(self):
+    def test_getting_not_existing_project_file(self):
         try:
             projectFile = self.project.get_resource('DoesNotExistFile.txt')
             self.fail('Should have failed')
         except RopeException:
             pass
 
-    def testWritingToProjectFiles(self):
-        projectFile = self.project.get_resource(self.projectMaker.getSampleFileName())
+    def test_writing_in_project_files(self):
+        projectFile = self.project.get_resource(self.projectMaker.get_sample_file_name())
         projectFile.write('another text\n')
         self.assertEquals('another text\n', projectFile.read())
 
         newFile = self.project.get_resource(projectFile)
         self.assertTrue(newFile is not None)
 
-    def testCreatingFilesThatAlreadyExist(self):
+    def test_creating_files_that_already_exist(self):
         try:
-            self.project.get_root_folder().create_file(self.projectMaker.getSampleFileName())
+            self.project.get_root_folder().create_file(self.projectMaker.get_sample_file_name())
             self.fail('Should have failed')
         except RopeException:
             pass
 
-    def testMakingRootFolderIfItDoesNotExist(self):
+    def test_making_root_folder_if_it_does_not_exist(self):
         projectRoot = 'SampleProject2'
         try:
             project = Project(projectRoot)
             self.assertTrue(os.path.exists(projectRoot) and os.path.isdir(projectRoot))
         finally:
-            SampleProjectMaker.removeRecursively(projectRoot)
+            SampleProjectMaker.remove_recursively(projectRoot)
 
-    def testFailureWhenProjectRootExistsAndIsAFile(self):
+    def test_failure_when_project_root_exists_and_is_a_file(self):
         projectRoot = 'SampleProject2'
         open(projectRoot, 'w').close()
         try:
         except RopeException:
             os.remove(projectRoot)
 
-    def testCreatingFolders(self):
+    def test_creating_folders(self):
         folderName = 'SampleFolder'
         self.project.get_root_folder().create_folder(folderName)
         folderPath = os.path.join(self.project.get_root_address(), folderName)
         self.assertTrue(os.path.exists(folderPath) and os.path.isdir(folderPath))
 
-    def testMakingAFolderThatAlreadyExists(self):
+    def test_making_folder_that_already_exists(self):
         folderName = 'SampleFolder'
         self.project.get_root_folder().create_folder(folderName)
         try:
         except RopeException:
             pass
 
-    def testFailingIfCreatingAFolderWhileAFileAlreadyExists(self):
+    def test_failing_if_creating_folder_while_file_already_exists(self):
         folderName = 'SampleFolder'
         self.project.get_root_folder().create_file(folderName)
         try:
         except RopeException:
             pass
 
-    def testCreatingAFileInsideAFolder(self):
+    def test_creating_file_inside_folder(self):
         folder_name = 'sampleFolder'
         file_name = 'sample2.txt'
         file_path = folder_name + '/' + file_name
                                             file_path))
                           .read())
 
-    def testFailingWhenCreatingAFileInsideANonExistantFolder(self):
+    def test_failing_when_creating_file_inside_non_existant_folder(self):
         try:
             self.project.get_root_folder().create_file('NonexistantFolder/SomeFile.txt')
             self.fail('Should have failed')
         except RopeException:
             pass
 
-    def testNestedDirectories(self):
+    def test_nested_directories(self):
         folder_name = 'SampleFolder'
         parent = self.project.get_root_folder().create_folder(folder_name)
         parent.create_folder(folder_name)
         folder_path = os.path.join(self.project.get_root_address(), folder_name, folder_name)
         self.assertTrue(os.path.exists(folder_path) and os.path.isdir(folder_path))
 
-    def testRemovingFiles(self):
+    def test_removing_riles(self):
         self.assertTrue(os.path.exists(os.path.join(self.project.get_root_address(),
-                                                    self.projectMaker.getSampleFileName())))
-        self.project.get_resource(self.projectMaker.getSampleFileName()).remove()
+                                                    self.projectMaker.get_sample_file_name())))
+        self.project.get_resource(self.projectMaker.get_sample_file_name()).remove()
         self.assertFalse(os.path.exists(os.path.join(self.project.get_root_address(),
-                                                     self.projectMaker.getSampleFileName())))
+                                                     self.projectMaker.get_sample_file_name())))
                           
-    def testRemovingDirectories(self):
+    def test_removing_directories(self):
         self.assertTrue(os.path.exists(os.path.join(self.project.get_root_address(),
-                                                    self.projectMaker.getSampleFolderName())))
-        self.project.get_resource(self.projectMaker.getSampleFolderName()).remove()
+                                                    self.projectMaker.get_sample_folder_name())))
+        self.project.get_resource(self.projectMaker.get_sample_folder_name()).remove()
         self.assertFalse(os.path.exists(os.path.join(self.project.get_root_address(),
-                                                     self.projectMaker.getSampleFolderName())))
+                                                     self.projectMaker.get_sample_folder_name())))
 
-    def testRemovingNonExistantFiles(self):
+    def test_removing_non_existant_files(self):
         try:
             self.project.get_resource('NonExistantFile.txt').remove()
             self.fail('Should have failed')
         except RopeException:
             pass
 
-    def testRemovingNestedFiles(self):
-        fileName = self.projectMaker.getSampleFolderName() + '/SampleFile.txt'
+    def test_removing_nested_files(self):
+        fileName = self.projectMaker.get_sample_folder_name() + '/SampleFile.txt'
         self.project.get_root_folder().create_file(fileName)
         self.project.get_resource(fileName).remove()
         self.assertTrue(os.path.exists(os.path.join(self.project.get_root_address(),
-                                                    self.projectMaker.getSampleFolderName())))
+                                                    self.projectMaker.get_sample_folder_name())))
         self.assertTrue(not os.path.exists(os.path.join(self.project.get_root_address(),
                                   fileName)))
 
-    def testFileGetName(self):
-        file = self.project.get_resource(self.projectMaker.getSampleFileName())
-        self.assertEquals(self.projectMaker.getSampleFileName(), file.get_name())
+    def test_file_get_name(self):
+        file = self.project.get_resource(self.projectMaker.get_sample_file_name())
+        self.assertEquals(self.projectMaker.get_sample_file_name(), file.get_name())
         file_name = 'nestedFile.txt'
-        parent = self.project.get_resource(self.projectMaker.getSampleFolderName())
-        filePath = self.projectMaker.getSampleFolderName() + '/' + file_name
+        parent = self.project.get_resource(self.projectMaker.get_sample_folder_name())
+        filePath = self.projectMaker.get_sample_folder_name() + '/' + file_name
         parent.create_file(file_name)
         nestedFile = self.project.get_resource(filePath)
         self.assertEquals(file_name, nestedFile.get_name())
 
-    def testFolderGetName(self):
-        folder = self.project.get_resource(self.projectMaker.getSampleFolderName())
-        self.assertEquals(self.projectMaker.getSampleFolderName(), folder.get_name())
+    def test_folder_get_name(self):
+        folder = self.project.get_resource(self.projectMaker.get_sample_folder_name())
+        self.assertEquals(self.projectMaker.get_sample_folder_name(), folder.get_name())
 
-    def testFileget_path(self):
-        file = self.project.get_resource(self.projectMaker.getSampleFileName())
-        self.assertEquals(self.projectMaker.getSampleFileName(), file.get_path())
+    def test_file_get_path(self):
+        file = self.project.get_resource(self.projectMaker.get_sample_file_name())
+        self.assertEquals(self.projectMaker.get_sample_file_name(), file.get_path())
         fileName = 'nestedFile.txt'
-        parent = self.project.get_resource(self.projectMaker.getSampleFolderName())
-        filePath = self.projectMaker.getSampleFolderName() + '/' + fileName
+        parent = self.project.get_resource(self.projectMaker.get_sample_folder_name())
+        filePath = self.projectMaker.get_sample_folder_name() + '/' + fileName
         parent.create_file(fileName)
         nestedFile = self.project.get_resource(filePath)
         self.assertEquals(filePath, nestedFile.get_path())
 
     def test_folder_get_path(self):
-        folder = self.project.get_resource(self.projectMaker.getSampleFolderName())
-        self.assertEquals(self.projectMaker.getSampleFolderName(), folder.get_path())
+        folder = self.project.get_resource(self.projectMaker.get_sample_folder_name())
+        self.assertEquals(self.projectMaker.get_sample_folder_name(), folder.get_path())
 
     def test_is_folder(self):
-        self.assertTrue(self.project.get_resource(self.projectMaker.getSampleFolderName()).is_folder())
-        self.assertTrue(not self.project.get_resource(self.projectMaker.getSampleFileName()).is_folder())
+        self.assertTrue(self.project.get_resource(self.projectMaker.get_sample_folder_name()).is_folder())
+        self.assertTrue(not self.project.get_resource(self.projectMaker.get_sample_file_name()).is_folder())
 
     def testget_children(self):
-        children = self.project.get_resource(self.projectMaker.getSampleFolderName()).get_children()
+        children = self.project.get_resource(self.projectMaker.get_sample_folder_name()).get_children()
         self.assertEquals([], children)
     
     def test_nonempty_get_children(self):
         file_name = 'nestedfile.txt'
-        filePath = self.projectMaker.getSampleFolderName() + '/' + file_name
-        parent = self.project.get_resource(self.projectMaker.getSampleFolderName())
+        filePath = self.projectMaker.get_sample_folder_name() + '/' + file_name
+        parent = self.project.get_resource(self.projectMaker.get_sample_folder_name())
         parent.create_file(file_name)
         children = parent.get_children()
         self.assertEquals(1, len(children))
     def test_nonempty_get_children2(self):
         file_name = 'nestedfile.txt'
         folder_name = 'nestedfolder.txt'
-        filePath = self.projectMaker.getSampleFolderName() + '/' + file_name
-        folderPath = self.projectMaker.getSampleFolderName() + '/' + folder_name
-        parent = self.project.get_resource(self.projectMaker.getSampleFolderName())
+        filePath = self.projectMaker.get_sample_folder_name() + '/' + file_name
+        folderPath = self.projectMaker.get_sample_folder_name() + '/' + folder_name
+        parent = self.project.get_resource(self.projectMaker.get_sample_folder_name())
         parent.create_file(file_name)
         parent.create_folder(folder_name)
         children = parent.get_children()
     def test_getting_files(self):
         files = self.project.get_root_folder().get_files()
         self.assertEquals(1, len(files))
-        self.assertTrue(self.project.get_resource(self.projectMaker.getSampleFileName()) in files)
+        self.assertTrue(self.project.get_resource(self.projectMaker.get_sample_file_name()) in files)
         
     def test_getting_folders(self):
         folders = self.project.get_root_folder().get_folders()
         self.assertEquals(1, len(folders))
-        self.assertTrue(self.project.get_resource(self.projectMaker.getSampleFolderName()) in folders)
+        self.assertTrue(self.project.get_resource(self.projectMaker.get_sample_folder_name()) in folders)
 
     def test_nested_folder_get_files(self):
         parent = self.project.get_root_folder().create_folder('top')
     def testGetAllFiles(self):
         files = self.project.get_files()
         self.assertEquals(1, len(files))
-        self.assertEquals(self.projectMaker.getSampleFileName(), files[0].get_name())
+        self.assertEquals(self.projectMaker.get_sample_file_name(), files[0].get_name())
 
     def testMultifileGetAllFiles(self):
         fileName = 'nestedFile.txt'
-        parent = self.project.get_resource(self.projectMaker.getSampleFolderName())
+        parent = self.project.get_resource(self.projectMaker.get_sample_folder_name())
         parent.create_file(fileName)
         files = self.project.get_files()
         self.assertEquals(2, len(files))
 
     def test_folder_creating_nested_files(self):
         project_file = 'NewFile.txt'
-        parent_folder = self.project.get_resource(self.projectMaker.getSampleFolderName())
+        parent_folder = self.project.get_resource(self.projectMaker.get_sample_folder_name())
         parent_folder.create_file(project_file)
-        newFile = self.project.get_resource(self.projectMaker.getSampleFolderName()
+        newFile = self.project.get_resource(self.projectMaker.get_sample_folder_name()
                                             + '/' + project_file)
         self.assertTrue(new_file is not None and not new_file.is_folder())
 
 
     def test_folder_creating_nested_files(self):
         project_file = 'newfolder'
-        parent_folder = self.project.get_resource(self.projectMaker.getSampleFolderName())
+        parent_folder = self.project.get_resource(self.projectMaker.get_sample_folder_name())
         parent_folder.create_folder(project_file)
-        new_folder = self.project.get_resource(self.projectMaker.getSampleFolderName()
+        new_folder = self.project.get_resource(self.projectMaker.get_sample_folder_name()
                                                + '/' + project_file)
         self.assertTrue(new_folder is not None and new_folder.is_folder())
 
     def setUp(self):
         unittest.TestCase.setUp(self)
         self.projectMaker = SampleProjectMaker()
-        self.project = Project(self.projectMaker.getRoot())
+        self.project = Project(self.projectMaker.get_root())
         self.finder = FileFinder(self.project)
-        self.project.get_resource(self.projectMaker.getSampleFileName()).remove()
+        self.project.get_resource(self.projectMaker.get_sample_file_name()).remove()
         self.file1 = 'aa'
         self.file2 = 'abb'
         self.file3 = 'abc'
         self.file4 = 'b'
-        self.parent = self.project.get_resource(self.projectMaker.getSampleFolderName())
+        self.parent = self.project.get_resource(self.projectMaker.get_sample_folder_name())
         self.parent.create_file(self.file1)
         self.parent.create_file(self.file2)
         self.parent.create_file(self.file3)
         self.parent.create_file(self.file4)
         
     def tearDown(self):
-        self.projectMaker.removeAll()
+        self.projectMaker.remove_all()
         unittest.TestCase.tearDown(self)
 
     def testEmptyFinding(self):
     def setUp(self):
         unittest.TestCase.setUp(self)
         self.projectMaker = SampleProjectMaker()
-        self.project = Project(self.projectMaker.getRoot())
+        self.project = Project(self.projectMaker.get_root())
 
     def tearDown(self):
-        self.projectMaker.removeAll()
+        self.projectMaker.remove_all()
         unittest.TestCase.tearDown(self)
 
     def make_sample_python_file(self, file_path, get_text_function_source=None):
 from distutils.core import setup
 
 setup(name='rope',
-      version='0.1',
+      version='0.2pre',
       description='A Python IDE',
       author='Ali Gholami Rudi',
       author_email='aligrudi@users.sourceforge.net',
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.