def main():
prj = Project(os.path.realpath("../shuup/core/models"))
rst = Restructure(prj, "_(${str})", "")
rst.template = LanguageTwist("./shuup_fi_to_en.po")
twist_set = rst.get_changes()
for chg in twist_set.changes:
print(chg.get_description()) # noqa
prj.do(twist_set)
def inline(inline_fns, dirname, filename):
project = Project(dirname)
resource = project.get_resource(filename)
for inline_fn in inline_fns:
try: # FIXME: temporarily handling not implemented error
changes = create_inline(
project, resource,
resource.read().index(inline_fn)).get_changes(remove=True)
project.do(changes)
except Exception as e:
pass
def main():
prj = Project(os.path.realpath("../shuup/core/models"))
rst = Restructure(prj, "_(${str})", "")
rst.template = LanguageTwist("./shuup_fi_to_en.po")
twist_set = rst.get_changes()
for chg in twist_set.changes:
print(chg.get_description())
prj.do(twist_set)
def _rename_package(project: Project, old_name: str, new_name: str) -> None:
"""
Rename a Python package, refactoring relevant imports along the way,
as well as references in comments.
Args:
project: rope.base.Project holding the scope of the refactoring.
old_name: Old module name. Can be a fully qualified module path,
e.g. "package.pipelines.pipeline" or "package/pipelines/pipeline",
relative to the `project` root.
new_name: New module name. Can't be a fully qualified module path.
"""
folder = project.get_folder(old_name)
change = Rename(project, folder).get_changes(new_name, docs=True)
project.do(change)
class Agent(object):
def __init__(self, target_file, dry_run):
self.project = Project(os.getcwd())
self.target_file = target_file
self.dry_run = dry_run
self.commands = []
@property
def resource(self):
return File(self.project, self.target_file)
def add_command_class(self, command_class):
self.commands.append(command_class)
def do(self):
commands = [
command_class(self.project, self.target_file, self.dry_run)
for command_class in self.commands
]
changesets = filter(
lambda x: x is not None,
[
command.get_changeset()
for command in commands
]
)
# merge changesets
def merge_changesets(aggregated_changeset, next_changeset):
for change in next_changeset.changes:
aggregated_changeset.add_change(change)
aggregated_changeset.description += next_changeset.description
return aggregated_changeset
new_changeset = reduce(
merge_changesets,
changesets,
ChangeSet('')
)
if not new_changeset.changes:
return
if self.dry_run:
print new_changeset.get_description()
else:
self.project.do(new_changeset)
def rename(self, name):
tmp0 = self.area.get('1.0', 'insert')
offset = len(tmp0)
path = self.get_root_path()
project = Project(path)
mod = path_to_resource(project, self.area.filename)
renamer = Rename(project, mod, offset)
changes = renamer.get_changes(name)
project.do(changes)
self.update_instances(changes)
print('\nRope - Renamed resource ..\n')
print(changes.get_description())
self.area.chmode('NORMAL')
root.status.set_msg('Resources renamed!')
project.close()
def _move_package(project: Project, source: str, target: str) -> None:
"""
Move a Python package, refactoring relevant imports along the way.
A target of empty string means moving to the root of the `project`.
Args:
project: rope.base.Project holding the scope of the refactoring.
source: Name of the Python package to be moved. Can be a fully
qualified module path relative to the `project` root, e.g.
"package.pipelines.pipeline" or "package/pipelines/pipeline".
target: Destination of the Python package to be moved. Can be a fully
qualified module path relative to the `project` root, e.g.
"package.pipelines.pipeline" or "package/pipelines/pipeline".
"""
src_folder = project.get_module(source).get_resource()
target_folder = project.get_module(target).get_resource()
change = MoveModule(project, src_folder).get_changes(dest=target_folder)
project.do(change)
def move(self, name):
"""
"""
tmp0 = self.area.get('1.0', 'insert')
offset = len(tmp0)
path = self.get_root_path()
project = Project(path)
project = Project(path)
mod = path_to_resource(project, self.area.filename)
mover = create_move(project, mod, offset)
destin = path_to_resource(project, name)
changes = mover.get_changes(destin)
project.do(changes)
self.update_instances(changes)
project.close()
self.area.chmode('NORMAL')
root.status.set_msg('Resources moved!')
class rename:
def __init__(self, project_path=None, module_path=None):
""" initialize using project path and optional sub module path to limit rename scope """
if project_path:
self.project = Project(project_path)
self.module_path = module_path
self.words = set()
self.files = []
self.namemap = {}
self.classname_regex = re.compile('class\s+(?P<name>[a-zA-Z0-9_]+)')
self.methodname_regex = re.compile('def\s+(?P<name>[a-zA-Z0-9_]+)')
def load_words(self):
""" load all known words """
with open('words') as f:
for line in f:
self.words.add(line.strip().lower())
def load_dict(self, dictionary_path):
""" load a custom dict with new (recognized) and restricted (unrecognized) words """
doc = etree.parse(dictionary_path)
for recognized in doc.xpath('/dictionary/recognized/word'):
self.words.add(recognized.text)
for unrecognized in doc.xpath('/dictionary/unrecognized/word'):
if unrecognized.text in self.words:
self.words.remove(unrecognized.text)
def wash_word(self, string):
""" clean up word by separating prefix, suffix and word without underscores """
prefix = string[:string.find(string.lstrip('_'))]
suffix = string[len(string.rstrip('_')):]
word = string.lower().replace('_', '')
return (prefix, word, suffix)
def find_word(self, string, index):
""" find the longest word from index """
word = ''
i = index + 1
while i <= len(string):
if string[index:i] in self.words:
word = string[index:i]
i += 1
return word
def reverse_find_word(self, string, index):
""" backwards find the longest word from index """
word = ''
i = index - 1
while i >= 0:
if string[i:index] in self.words:
word = string[i:index]
i -= 1
return word
def find_words(self, string, index=-1):
""" find all known words in a string """
words = []
if index == -1:
index = len(string)
if index == 0:
return words
word = self.reverse_find_word(string, index)
if word:
words.insert(0, word)
index -= len(word)
else:
index -= 1
w = self.find_words(string, index)
w.extend(words)
words = w
#words.extend(self.find_words(string, index))
return words
def rename(self, string):
""" rename string to PEP8 standard """
index = 0
last_index = 0
new_name = ''
prefix, old_name, suffix = self.wash_word(string)
for word in self.find_words(old_name):
index = old_name.find(word, index)
if last_index != index:
new_name += old_name[last_index: index]
if len(new_name) > 0:
new_name += '_'
new_name += word
index += len(word)
last_index = index
if last_index != len(old_name):
if len(new_name) > 0:
new_name += '_'
new_name += old_name[last_index:]
return '%s%s%s' % (prefix, new_name, suffix)
def index_file(self, content):
""" get all indexes for methods to rename in context
return list of old name, position and new name """
index = 0
methods = []
running = True
while running:
method = self.methodname_regex.search(content, index)
if method:
old_name = method.group('name')
pos = method.start() + method.string[method.start():].find(old_name)
new_name = self.rename(old_name)
if old_name != new_name:
methods.append((old_name, pos, new_name))
index = pos + len(old_name)
else:
running = False
return methods
def get_files(self):
""" iterator for all valid project files """
for file_resource in self.project.get_files():
if self.module_path and not self.module_path in file_resource.real_path:
continue
yield file_resource
def dry_run(self):
""" list all methods to be renamed without updating any files """
for file_resource in self.get_files():
methods = self.index_file(file_resource.read())
print('%s' % file_resource.path)
for method in methods:
print(' %s:%d->%s' % (method[0], method[1], method[2]))
def refactor(self):
""" renames all methods to PEP8 standard """
for file_resource in self.get_files():
while True:
self.project.validate()
methods = self.index_file(file_resource.read())
if len(methods) == 0:
break
method = methods[0]
old_name = method[0]
pos = method[1]
new_name = method[2]
print('rename: %s:%d->%s' % (old_name, pos, new_name))
changes = Rename(self.project, file_resource, pos).get_changes(new_name)
self.project.do(changes)
def compile_with_top(source_path, api_path):
# parse the inputs to get the path subcomponents
source_path = op.abspath(source_path)
api_path = op.abspath(api_path)
api_root, api_name = op.split(api_path)
api_module = op.basename(op.normpath(api_root))
source_root, source_name = op.split(source_path)
# Create the two projects that we will be using
from rope.base.project import Project
project_const = Project(source_root, **prefs) # original project, used as a source and will not be modified
project_swap = Project(op.join(source_root, 'top_compiled'), **prefs)
if(op.isdir(source_path)):
pass
# copy over the files that will be compiled
source_mod = project_const.root.get_child(source_name)
try:
mod_code = project_swap.root.get_child(source_name)
except ResourceNotFoundError:
mod_code = project_swap.root.create_file(source_name)
mod_code.write(source_mod.read())
# Generate the api library package and copy it over
from rope.contrib import generate
api_pkg = None
if api_root != source_root: # If the api is in its own module, reproduce it
try:
api_pkg = project_swap.root.get_child(api_module)
except ResourceNotFoundError:
api_pkg = generate.create_package(project_swap, api_module)
try:
mod_api = project_swap.root.get_child('{}/{}'.format(api_module, api_name))
except ResourceNotFoundError:
mod_api = generate.create_module(project_swap, 'api', api_pkg)
# copy over the contents of the api so that rope can modify it
with open(api_path, 'r') as a:
api_content = a.read()
# mod_api.truncate().write(api_content)
mod_api.write(api_content)
# inline each API call
# first, get the list of all API function calls possible
import imp, types
api = imp.load_source(api_name, api_path)
api_calls = [a for a in dir(api) if isinstance(api.__dict__.get(a), types.FunctionType)]
# perform the replacement
for a in api_calls:
# We did not use this API call in the code, so skip replacing it
if re.search(r'\b{}\b'.format(a), mod_code.read()) is None:
continue
# print re.search(r'\b{}\b'.format(a), mod_code.read())
ind = re.search(r'\b{}\b'.format(a), mod_code.read()).start()
try:
inl = inline.create_inline(project_swap, mod_code, ind)
change = inl.get_changes()
project_const.do(change)
except RefactoringError:
print "The api cannot be properly connected from the code. Please ensure that you are importing the file with the API commands directly."
# Cleaning up
api_pkg.remove() # remove the API library from the compiled files
project_const.close()
project_swap.close()
from rope.base.project import Project
from rope.refactor.rename import Rename
proj = Project('../lib/ansible')
context = proj.get_file('context.py')
change = Rename(proj, context).get_changes('new_context')
proj.do(change)
from rope.base.project import Project
from rope.refactor.rename import Rename
from rope.contrib import generate
project = Project('.')
pycore = project.pycore
package = pycore.find_module('sindice')
changes = Rename(project, package).get_changes('core')
project.do(changes)
from rope.base.project import Project
from rope.base import libutils
from rope.refactor.move import create_move
myProj = Project('src')
# resource = myProj.get_resource(r'app/services/gridMaker/grid.py')
# resource = libutils.path_to_resource(myProj, r'src/app/services/gridMaker')
resource = myProj.get_resource(r'app/services/theGrid/windowSetter.py')
offset = None
destination = libutils.path_to_resource(
myProj, r'src/app/services/theGrid/windowSetter')
mover = create_move(myProj, resource, offset)
myProj.do(mover.get_changes(destination))
from rope.contrib import generate
args
project: type=rope.base.project.Project
Example #4::
pattern ${pow}(${param1}, ${param2})
goal ${param1} ** ${param2}
args pow: name=mod.pow, exact
Example #5::
pattern ${inst}.longtask(${p1}, ${p2})
goal
${inst}.subtask1(${p1})
${inst}.subtask2(${p2})
args
inst: type=mod.A,unsure
"""
restructuring = restructure.Restructure(project, pattern, goal, args)
project.do(restructuring.get_changes())
mod2.read()
u'import mod1\nprint(2 ** 3)\n'
# Cleaning up
# mod1.remove()
# mod2.remove()
project.close()
