Skip to main content
Donate to the Python Software Foundation or Purchase a PyCharm License to Benefit the PSF! Donate Now

a python refactoring IDE and library...

Project description

Overview

rope is a python refactoring IDE and library. The IDE uses the library to provide features like refactoring, code assist, and auto-completion. It is written in python. The IDE uses Tkinter library.

New Features

Core:

  • Enhanced static object inference
  • Holding per name information for builtin containers
  • Change signature for constructors
  • Adding ‘rename when unsure’ option
  • Enhanced returned object static object inference
  • Supporting generator functions
  • Handling *args and **kwds arguments
  • Showing pydoc for some of builtin types and functions

UI:

  • Filling paragraphs in text modes; M-q
  • Yanking; M-y
  • Repeating last command; C-x z
  • Enhancing show pydoc to include docs from superclasses

The most interesting features added in this release are related to rope’s object inference mechanisms. I’d rather show some small examples than going into to much detail here.

Enhanced static returned object inference:

class C(object):

    def c_func(self):
        return ['']

def a_func(arg):
    return arg.c_func()

a_var = a_func(C)

Here rope knows that the type of a_var is a list that holds strs.

Supporting generator functions:

class C(object):
    pass

def a_generator():
    yield C()


for c in a_generator():
    a_var = c

Here the objects a_var and c hold are known.

Another thing that has been added is SOI analysis (Available in Edit menu or by using C-c x s). It analyzes a module for finding useful object information. Currently it is used only when the user askes (Just like DOI), but in future that might change.

Many kinds of information is collected during SOI like per name data for builtin container types:

l1 = [C()]
var1 = l1.pop()

l2 = []
l2.append(C())
var2 = l2.pop()

Here rope knowns the type of var1 without doing anything. But for knowing the type of var2 we need to analyze the items added to l2 which might happen in other modules. Rope can find out that by running SOI analysis on this module.

You might be wondering is there any reason for using DOI instead of SOI. The answer is that DOI is more accurate and handles complex and dynamic situations. For example in:

def f(arg):
    return eval(arg)

a_var = f('C')

SOI can no way conclude the object a_var holds but it is really trivial for DOI. What’s more SOI analyzes calls only in one module while DOI analyzes any call that happens when running a module. That is for achieving the same result as DOI you might need to run SOI on more than one module and more than once (not considering dynamic situations.) One advantage of SOI is that it is much faster than DOI.

Many enhancements to rope’s object inference has been planned and till 0.5 release most of them will be implemented. I’ll write more about them in future releases.

‘Rename when unsure’ option has been added to rename refactoring. This option tells rope to rename when it doesn’t know whether it is an exact match or not. For example after renaming C.a_func when the ‘rename when unsure’ option is set in:

class C(object):

    def a_func(self):
        pass

def a_func(arg):
    arg.a_func()

C().a_func()

we would have:

class C(object):

    def new_func(self):
        pass

def a_func(arg):
    arg.new_func()

C().new_func()

Note that the global a_func was not renamed because we are sure that it is not a match. But when using this option there might be some unexpected renames. So only use this option when the name is not another python defined elements.

Project details


Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN SignalFx SignalFx Supporter DigiCert DigiCert EV certificate StatusPage StatusPage Status page