refactor and decouple processing

fix updating PHP method (offset was off)

fixes #5
fixes #6

Author: bogdananton

README.md

@@ -8,7 +8,7 @@ If the original phrase is inside a dockblock then it updates the method using th
 
 Install
 -----
-Install by downloading the [0.3 release zip](https://github.com/bogdananton/Sublime-testNameGenerator/releases/download/0.3/testNameGenerator.zip) and unpacking it into the \Packages folder (SublimeText Menu \ Preferences \ Browse Packages).
+Install by downloading the [1.0.1 release zip](https://github.com/bogdananton/Sublime-testNameGenerator/releases/download/1.0.1/testNameGenerator.zip) and unpacking it into the \Packages folder (SublimeText Menu \ Preferences \ Browse Packages).
 
 Usage
 -----

TestNameGenerator.py

@@ -1,81 +1,152 @@
-# v0.1
 import sublime, sublime_plugin, re
 
 class ConvertTestNameCommand(sublime_plugin.TextCommand):
+    def isAllowedSyntax(self, syntax):
+        return ((syntax == "PHP") | (syntax == "JavaScript"))
+
+    # keep only alphanum and ",", ".", "(", ")"
+    def getCleanLineContents(self, lineContents):
+        pattern = TextHelper.patternCleanLine()
+        return re.sub(pattern, '', lineContents)
+
+    def getFallbackLineContent(self, i):
+        return "blank" + str(i)
+
+    # convert to CamelCase and keep only alphanumeric chars
+    def getMethodName(self, lineContents):
+        pattern = TextHelper.patternMethodName()
+        return re.sub(pattern, '', lineContents.title())
+
+    def getExistingMethod(self, lineContents, cursorLine):
+        pageContents   = SublimeConnect.getPageContents(cursorLine)
+        lineContents   = re.escape(lineContents)
+        pattern        = TextHelper.patternExistingMethodPHP(lineContents)
+
+        searchExisting = re.search(pattern, pageContents)
+        if searchExisting != None:
+            if (searchExisting.group(7) is None) == False:
+                return searchExisting.group(7)
+        return False
+
+    # get a list of [test name with separate words, test name with no spaces in between and camel cased] from the current cursor(s) or selection(s)
     def run(self, edit):
-        # get a list of [test name with separate words, test name with no spaces in between and camel cased] from the current cursor(s) or selection(s)
+        SublimeConnect.init(self)
+        currentSyntax      = SublimeConnect.getSyntax()
         extractedTestNames = []
-
-        currentSyntax = self.getSyntax()
-        if ((currentSyntax != "PHP") & (currentSyntax != "JavaScript")):
+        
+        if False == self.isAllowedSyntax(currentSyntax):
             return
 
-        cursor = 0
-        # iterate over all cursors
-        for region in self.view.sel():
-            # extract line contents from cursor(s)
-            line = self.view.line(region)
-            lineContents = self.view.substr(line).strip()
-
-            # keep only alphanum and ",", ".", "(", ")"
-            testNameExpanded = re.sub(r'[^a-zA-Z0-9 \(\)_\:\.\,\[\]]', '', lineContents).strip()
+        i = 0
+        for cursor in SublimeConnect.getCursors():
+            cursorLine   = SublimeConnect.getLine(cursor)
+            lineContents = SublimeConnect.getLineContents(cursorLine)
+            phrase       = self.getCleanLineContents(lineContents)
 
             # if extracted line contents are empty, use "blank"
-            if not testNameExpanded:
-                testNameExpanded = "blank"
-                if cursor > 0:
-                    testNameExpanded += str(cursor)
-                cursor += 1
-
-            # convert to CamelCase and keep only alphanumeric chars
-            testNameContracted = testNameExpanded.title()
-            testNameContracted = re.sub(r'[^a-zA-Z0-9_]', '', testNameContracted)
+            if not phrase:
+                phrase = self.getFallbackLineContent(i)
+                i += 1
 
             if (currentSyntax == "PHP"):
-                content = self.view.substr(sublime.Region(0, self.view.size()))
-                r = (re.search(r'\/\*([\*\n\s]+)' + re.escape(lineContents.strip())  + '([a-zA-Z0-9\n\s\*@]+)\*\/([\s]+)(public)?(\s)?function(\s)?test([a-zA-Z0-9_]+)(\s\n)?\(', content))
-                if (r == None):
-                    # insert new test method
-                    self.view.replace(edit, line, self.prepareTestContent(testNameExpanded, testNameContracted, currentSyntax))
+                methodName     = self.getMethodName(phrase)
+                existingMethod = self.getExistingMethod(lineContents, cursorLine)
+                print(existingMethod)
+
+                if existingMethod == False:
+                    SublimeConnect.insertMethodName(edit, cursorLine, TextHelper.prepareTestBlockPHP(phrase, methodName))
                 else:
-                    if (r.group(7) != None):
-                        s              = "test"+r.group(7) # search for current test name
-                        methodPosition = content.find(s)
-                        line           = self.view.line(sublime.Region(methodPosition, methodPosition + len(s)))
-                        tab            = self.getWhitespaceTab()
-                        lineContents   = self.view.substr(line).strip()
-                        lineContents   = lineContents.replace(s, "test"+testNameContracted)
-                        self.view.replace(edit, line, tab + lineContents)
+                    SublimeConnect.updateMethodNamePHP(edit, cursorLine, methodName, existingMethod)
 
             else:
                 # JS will add a new test method because the text is inside the test method
-                # replace current line
-                self.view.replace(edit, line, self.prepareTestContent(testNameExpanded, testNameContracted, currentSyntax))
-
-    def prepareTestContent(self, testNameExpanded, testNameContracted, languageSyntax):
-        returnContent = ""
-
-        tab = self.getWhitespaceTab()
-
-        if (languageSyntax == "PHP"):
-            returnContent = tab + "/**\n" + tab + " * " + testNameExpanded + "\n" + tab + " */\n" + tab + "public function test"+testNameContracted+"()\n" + tab + "{\n\n" + tab + "}\n\n" + tab
-
-        elif (languageSyntax == "JavaScript"):
-            # will generate Jasmine blocks
-            examineNameTypeParts = testNameExpanded.split(" ")
-
-            if (examineNameTypeParts[0].lower() == "describe"):
-                examineNameTypeParts.pop(0) # remove the "describe" prefix
-                returnContent = tab + "describe('"+ (" ".join(examineNameTypeParts)) +"', function () {\n\n" + tab + "});\n\n" + tab
-            else:
-                returnContent = tab + tab + "it('"+testNameExpanded+"', function () {\n\n" + tab + "" + tab + "});\n\n" + tab
-
-        return returnContent
+                SublimeConnect.insertMethodName(edit, cursorLine, TextHelper.prepareTestBlockJS(phrase))
+
+class TextHelper():
+    def patternExistingMethodPHP(lineContents):
+        # complete block: return r'\/\*([\*\n\s]+)' + lineContents + '([a-zA-Z0-9\n\s\*@]+)\*\/([\s]+)(public)?(\s)?function(\s)?test([a-zA-Z0-9_]+)(\s\n)?\('
+        return r'([\*\n\s]+)' + lineContents + '([a-zA-Z0-9\n\s\*@]+)\*\/([\s]+)(public)?(\s)?function(\s)?test([a-zA-Z0-9_]+)(\s\n)?\('
+
+    def patternCleanLine():
+        return r'[^a-zA-Z0-9 \(\)_\:\.\,\[\]]'
+
+    def patternMethodName():
+        return r'[^a-zA-Z0-9_]'
+
+    def prepareTestBlockPHP(phrase, methodName):
+        tab = SublimeConnect.getWhitespaceTab()
+        return tab + "/**\n" + tab + " * " + phrase + "\n" + tab + " */\n" + tab + "public function test" + methodName + "()\n" + tab + "{\n\n" + tab + "}\n\n" + tab
+
+    # will generate Jasmine blocks
+    def prepareTestBlockJS(phrase):
+        tab                  = SublimeConnect.getWhitespaceTab()
+        examineNameTypeParts = phrase.split(" ")
+
+        if (examineNameTypeParts[0].lower() == "describe"):
+            phrase = " ".join(examineNameTypeParts.pop(0)) # remove the "describe" prefix
+            return self.getJasmineDescribeBlock(phrase, tab)
+
+        else:
+            return self.getJasmineItBlock(phrase, tab)
+
+    def getJasmineDescribeBlock(phrase, tab):
+        return tab + "describe('" +  phrase + "', function () {\n\n" + tab + "});\n\n" + tab
+
+    def getJasmineItBlock(phrase, tab):
+        return tab + tab + "it('" + phrase + "', function () {\n\n" + tab + "" + tab + "});\n\n" + tab
+
+# connector to the sublime api
+class SublimeConnect():
+    context = False
+
+    @classmethod
+    def getPageContents(self, cursorLine):
+        cursorPosition = cursorLine.begin()
+        return self.context.view.substr(sublime.Region(0, self.context.view.size()))
+
+    @classmethod
+    def updateMethodNamePHP(self, edit, cursorLine, methodName, existingMethodResults):
+        tab            = SublimeConnect.getWhitespaceTab()
+        searchExisting = "test" + existingMethodResults # search for current test name
+        methodPosition = self.getPageContents(cursorLine).find(searchExisting)
+        region         = sublime.Region(methodPosition, methodPosition + len(searchExisting))
+        # debug: self.context.view.add_regions('highlighted_lines', [region] , 'mark', 'dot', sublime.DRAW_OUTLINED) 
+
+        lineToUpdate   = self.context.view.line(region)
+        lineContents   = self.context.view.substr(lineToUpdate).strip().replace(searchExisting, "test" + methodName)
+        
+        self.context.view.replace(edit, lineToUpdate, tab + lineContents)
+
+    @classmethod
+    def insertMethodName(self, edit, cursorLine, testBlock):
+        self.context.view.replace(edit, cursorLine, testBlock)
+
+    @classmethod
+    def getLine(self, region):
+        return self.context.view.line(region)
+
+    @classmethod
+    def getLineContents(self, cursorLine):
+        return self.context.view.substr(cursorLine).strip()
+
+    @classmethod
+    def getCursors(self):
+        return self.context.view.sel()
+
+    @classmethod
+    def init(self, mainContext):
+        self.context = mainContext
+        return self
+    
+    # returns: PHP,JavaScript,...
+    @classmethod
+    def getSyntax(self):
+        return self.context.view.settings().get('syntax').replace('.tmLanguage', '').split("/")[1]
 
+    # returns tab character or spaces as an indent unit, based on the editor's settings
+    @classmethod
     def getWhitespaceTab(self):
-        if (self.view.settings().get('translate_tabs_to_spaces')):
-            return "".rjust(self.view.settings().get('tab_size'), ' ')
+        settings = self.context.view.settings()
+        if (settings.get('translate_tabs_to_spaces')):
+            return "".rjust(settings.get('tab_size'), ' ')
         return "\t";
-
-    def getSyntax(self):
-        return self.view.settings().get('syntax').replace('.tmLanguage', '').split("/")[1]