Commits

Anonymous committed e2d29ea

overview.txt: updated some of the sections

Comments (0)

Files changed (1)

 -------------------
 
 `rope.refactor.inline.create_inline()` creates an `InlineParameter`
-object when it is performed on a parameter.  It passes the default
-value of the parameter wherever its function is called without passing
-it.  For instance in::
+object when performed on a parameter.  It passes the default value of
+the parameter wherever its function is called without passing it.  For
+instance in::
 
   def f(p1=1, p2=1):
       pass
 
 Implicit interfaces are the interfaces that you don't explicitly
 define; But you expect a group of classes to have some common
-attributes.  These kinds of interfaces are very common in dynamic
-languages; Since we only have implementation inheritance and not
-interface inheritance.  For instance::
+attributes.  These interfaces are very common in dynamic languages;
+Since we only have implementation inheritance and not interface
+inheritance.  For instance::
 
   class A(object):
 
   count_for(B())
 
 This also works for change method signature.  Note that this feature
-relies on rope's object inference mechanisms to find out the
-parameters that are passed to a function.
+relies on rope's object analysis mechanisms to find out the parameters
+that are passed to a function.
 
 
 Restructurings
 
 `rope.refactor.restructure` can be used for performing restructurings.
 A restructuring is a program transformation; not as well defined as
-other refactorings like rename.  Let's see some examples (for more
-examples, see the pydocs in `rope.base.restructure` module).
+other refactorings like rename.  In this section, we'll see some
+examples.  After this example you might like to have a look at:
+
+* `rope.refactor.restructure` for more examples and features not
+  described here like adding imports to changed modules.
+* `rope.refactor.wildcards` for an overview of the arguments the
+  default wildcard supports.
+
+Finally, restructurings can be improved in many ways (for instance
+adding new wildcards).  You might like to discuss your ideas in the
+mailing list.
+
 
 Example 1
 '''''''''
 The arguments a wildcard takes is based on its type.
 
 For checking the type of a wildcard, we can pass ``type=value`` as an
-arg; ``value`` should be resolved to a python variable (or reference).
-For instance for showing `pow` in this example we can use `mod.pow`.
-As you see this string should start from module name.  For referencing
-python builtin types and functions you can use `__builtin__` module
-(for instance `__builtin__.int`).
+argument; ``value`` should be resolved to a python variable (or
+reference).  For instance for specifying `pow` in this example we can
+use `mod.pow`.  As you see, this string should start from module name.
+For referencing python builtin types and functions you can use
+`__builtin__` module (for instance `__builtin__.int`).
 
-For solving the mentioned problem we change our `pattern`.  But `goal`
-remains the same::
+For solving the mentioned problem, we change our `pattern`.  But
+`goal` remains the same::
 
   pattern: ${pow_func}(${param1}, ${param2})
   goal: ${param1} ** ${param2}
           print p
 
       def f2(self, p):
-          print p2
+          print p
 
 
   a = A()
           print p
 
       def f2(self, p):
-          print p2
+          print p
 
 
   a = A()