Camel Case Handling Tool: comparison PluginSplitMergeCamelCase.py

-:781a678e6c84
+:a29b5f01c2fa
 class SplitMergeCamelCasePlugin(QObject):
 """
 Class implementing the split, merge or convert camel case plug-in.
 """
 def __init__(self, ui):
 """
 Constructor
 @param ui reference to the user interface object
 @type UserInterface
 """
 super().__init__(ui)
 self.__ui = ui
 self.__translator = None
 self.__loadTranslator()
 self.__initMenu()
 self.__editors = {}
 self.__mainActions = []
 def activate(self):
 """
 Public method to activate this plugin.
 @return tuple of None and activation status
 @rtype tuple of (None, bool)
 """
 global error
-error = ""     # clear previous error
+error = ""  # clear previous error
 self.__ui.showMenu.connect(self.__populateMenu)
 menu = self.__ui.getMenu("plugin_tools")
 if menu is not None:
 if not menu.isEmpty():
 act = menu.addSeparator()
 self.__mainActions.append(act)
 act = menu.addMenu(self.__menu)
 self.__mainActions.append(act)
-ericApp().getObject("ViewManager").editorOpenedEd.connect(
+ericApp().getObject("ViewManager").editorOpenedEd.connect(self.__editorOpened)
-self.__editorOpened)
+ericApp().getObject("ViewManager").editorClosedEd.connect(self.__editorClosed)
-ericApp().getObject("ViewManager").editorClosedEd.connect(
-self.__editorClosed)
 for editor in ericApp().getObject("ViewManager").getOpenEditors():
 self.__editorOpened(editor)
 return None, True
 def deactivate(self):
 """
 Public method to deactivate this plugin.
 """
 self.__ui.showMenu.disconnect(self.__populateMenu)
 menu = self.__ui.getMenu("plugin_tools")
 if menu is not None:
 for act in self.__mainActions:
 menu.removeAction(act)
 self.__mainActions = []
 ericApp().getObject("ViewManager").editorOpenedEd.disconnect(
-self.__editorOpened)
+self.__editorOpened
+)
 ericApp().getObject("ViewManager").editorClosedEd.disconnect(
-self.__editorClosed)
+self.__editorClosed
+)
 for editor, acts in self.__editors.items():
 editor.showMenu.disconnect(self.__editorShowMenu)
 menu = editor.getMenu("Tools")
 if menu is not None:
 for act in acts:
 menu.removeAction(act)
 self.__editors = {}
 def __loadTranslator(self):
 """
 Private method to load the translation file.
 """
 if self.__ui is not None:
 loc = self.__ui.getLocale()
 if loc and loc != "C":
 locale_dir = os.path.join(
-os.path.dirname(__file__), "SplitMergeCamelCase", "i18n")
+os.path.dirname(__file__), "SplitMergeCamelCase", "i18n"
+)
 translation = "splitmergecamelcase_{0}".format(loc)
 translator = QTranslator(None)
 loaded = translator.load(translation, locale_dir)
 if loaded:
 self.__translator = translator
 ericApp().installTranslator(self.__translator)
 else:
-print("Warning: translation file '{0}' could not be"
+print(
-" loaded.".format(translation))
+"Warning: translation file '{0}' could not be"
+" loaded.".format(translation)
+)
 print("Using default.")
 def __initMenu(self):
 """
 Private method to initialize the camel case handling menu.
 """
 self.__menu = QMenu(self.tr("Camel/Snake Case Handling"))
-self.__menu.addAction(
+self.__menu.addAction(self.tr("Split from Camel Case"), self.__splitCamelCase)
-self.tr("Split from Camel Case"),
+self.__menu.addAction(self.tr("Merge to Camel Case"), self.__mergeCamelCase)
-self.__splitCamelCase)
-self.__menu.addAction(
-self.tr("Merge to Camel Case"),
-self.__mergeCamelCase)
 self.__menu.addAction(
 self.tr("Merge to Camel Case (upper case first)"),
-self.__mergeCamelCaseUppercaseFirst)
+self.__mergeCamelCaseUppercaseFirst,
+)
+self.__menu.addSeparator()
+self.__menu.addAction(self.tr("Split from Snake Case"), self.__splitSnakeCase)
+self.__menu.addAction(self.tr("Merge to Snake Case"), self.__mergeSnakeCase)
 self.__menu.addSeparator()
 self.__menu.addAction(
-self.tr("Split from Snake Case"),
+self.tr("Camel Case to Snake Case"), self.__camelCaseToSnakeCase
-self.__splitSnakeCase)
+)
 self.__menu.addAction(
-self.tr("Merge to Snake Case"),
+self.tr("Snake Case to Camel Case"), self.__snakeCaseToCamelCase
-self.__mergeSnakeCase)
+)
-self.__menu.addSeparator()
-self.__menu.addAction(
-self.tr("Camel Case to Snake Case"),
-self.__camelCaseToSnakeCase)
-self.__menu.addAction(
-self.tr("Snake Case to Camel Case"),
-self.__snakeCaseToCamelCase)
 self.__menu.addAction(
 self.tr("Snake Case to Camel Case (upper case first)"),
-self.__snakeCaseToCamelCaseUppercaseFirst)
+self.__snakeCaseToCamelCaseUppercaseFirst,
+)
 def __populateMenu(self, name, menu):
 """
 Private slot to populate the tools menu with our entries.
 @param name name of the menu
 @type str
 @param menu reference to the menu to be populated
 @type QMenu
 """
 if name not in ["Tools", "PluginTools"]:
 return
 editor = ericApp().getObject("ViewManager").activeWindow()
 if name == "Tools":
 if not menu.isEmpty():
 menu.addSeparator()
 act = menu.addMenu(self.__menu)
 act.setEnabled(editor is not None and editor.hasSelectedText())
 elif name == "PluginTools" and self.__mainActions:
-self.__menu.setEnabled(editor is not None and
+self.__menu.setEnabled(editor is not None and editor.hasSelectedText())
-editor.hasSelectedText())
 def __editorOpened(self, editor):
 """
 Private slot called, when a new editor was opened.
 @param editor reference to the new editor
 @type Editor
 """
 menu = editor.getMenu("Tools")
 if menu is not None:
 act = menu.addSeparator()
 self.__editors[editor].append(act)
 act = menu.addMenu(self.__menu)
 self.__editors[editor].append(act)
 editor.showMenu.connect(self.__editorShowMenu)
 def __editorClosed(self, editor):
 """
 Private slot called, when an editor was closed.
 @param editor reference to the editor
 @type Editor
 """
 with contextlib.suppress(KeyError):
 del self.__editors[editor]
 def __editorShowMenu(self, menuName, menu, editor):
 """
 Private slot called, when the the editor context menu or a submenu is
 about to be shown.
 @param menuName name of the menu to be shown
 @type str
 @param menu reference to the menu
 @type QMenu
 @param editor reference to the editor
 if not menu.isEmpty():
 act = menu.addSeparator()
 self.__editors[editor].append(act)
 act = menu.addMenu(self.__menu)
 self.__editors[editor].append(act)
 self.__menu.setEnabled(editor.hasSelectedText())
 def __applyChange(self, newText, editor):
 """
 Private method to change the selected text.
 @param newText new (converted) text
 @type str
 @param editor reference to the editor to apply the text
 change to
 @type Editor
 """
 editor.beginUndoAction()
 editor.replaceSelectedText(newText)
 editor.endUndoAction()
 def __splitCamelCase(self):
 """
 Private slot to split the selected camel case text.
 """
 editor = ericApp().getObject("ViewManager").activeWindow()
 if editor is None:
 return
 text = editor.selectedText()
 if text:
 newText = re.sub(r"([A-Z])", r" \1", text).lstrip(" ")
 if newText != text:
 self.__applyChange(newText, editor)
 def __mergeCamelCase(self, uppercaseFirst=False):
 """
 Private slot to merge the selected text to camel case.
 @param uppercaseFirst flag indicating to upper case the
 first character
 @type bool
 """
 editor = ericApp().getObject("ViewManager").activeWindow()
 if editor is None:
 return
 text = editor.selectedText()
 if text:
 newText = "".join(w[0].upper() + w[1:] for w in text.split())
 if not uppercaseFirst:
 newText = newText[0].lower() + newText[1:]
 if newText != text:
 self.__applyChange(newText, editor)
 def __mergeCamelCaseUppercaseFirst(self):
 """
 Private slot to merge the selected text to camel case upper casing
 the first character.
 """
 self.__mergeCamelCase(True)
 def __splitSnakeCase(self):
 """
 Private slot to split the selected snake case text.
 """
 editor = ericApp().getObject("ViewManager").activeWindow()
 if editor is None:
 return
 text = editor.selectedText()
 if text:
 newText = text.replace("_", " ").lstrip(" ")
 if newText != text:
 self.__applyChange(newText, editor)
 def __mergeSnakeCase(self):
 """
 Private slot to merge the selected text to snake case.
 """
 editor = ericApp().getObject("ViewManager").activeWindow()
 if editor is None:
 return
 text = editor.selectedText()
 if text:
 newText = "_".join(w.lower() for w in text.split())
 if newText != text:
 self.__applyChange(newText, editor)
 def __camelCaseToSnakeCase(self):
 """
 Private slot to convert camel case text to underscore separated text.
 """
 editor = ericApp().getObject("ViewManager").activeWindow()
 if editor is None:
 return
 text = editor.selectedText()
 if text:
 newText = re.sub(r"([A-Z])", r"_\1", text).lower().lstrip("_")
 if text.startswith("__"):
 newText = "__" + newText
 elif text.startswith("_"):
 newText = "_" + newText
 if newText != text:
 self.__applyChange(newText, editor)
 def __snakeCaseToCamelCase(self, uppercaseFirst=False):
 """
 Private slot to convert underscore separated text to camel case.
 @param uppercaseFirst flag indicating to upper case the
 first character
 @type bool
 """
 editor = ericApp().getObject("ViewManager").activeWindow()
 if editor is None:
 return
 text = editor.selectedText()
 if text:
 newText = "".join(s.capitalize() for s in text.split("_"))
 if not uppercaseFirst:
 newText = newText[0].lower() + newText[1:]
 newText = "__" + newText
 elif text.startswith("_"):
 newText = "_" + newText
 if newText != text:
 self.__applyChange(newText, editor)
 def __snakeCaseToCamelCaseUppercaseFirst(self):
 """
 Private slot to convert underscore separated text to camel case
 upper casing the first character.
 """
 self.__snakeCaseToCamelCase(True)
 #
 # eflag: noqa = M801

Mercurial Repositories > Camel Case Handling Tool / file comparison

comparison: PluginSplitMergeCamelCase.py

PluginSplitMergeCamelCase.py