Merge remote-tracking branch 'origin/master'

Author: cawolf

src/main/kotlin/de/cawolf/quickmock/intention/Constants.kt

@@ -2,6 +2,8 @@ package de.cawolf.quickmock.intention
 
 const val RESOURCE_BUNDLE = "QuickMock"
 
+const val GENERATED_SUFFIX = "QuickMocked"
+
 @JvmField
 val PRIMITIVES = arrayOf(
         "string",

src/main/kotlin/de/cawolf/quickmock/intention/QuickMockCreator.kt

@@ -64,12 +64,16 @@ class QuickMockCreator : PsiElementBaseIntentionAction(), IntentionAction {
 
         removeWhitespaceBeforeConstruct.invoke(constructStatement)
 
+        val parameterMapByName = ArrayList<Pair<String, Parameter>>(parametersWithoutMocks.size)
         for (parameter in parametersWithoutMocks) {
             val parameterClassName = parameter.type.toString()
-            nonPrimitiveMocked = addMissingUseStatements.invoke(namespace, parameterClassName, aliasedUseStatementList.get(parameterClassName)) || nonPrimitiveMocked
-            addMockAssignment.invoke(project, constructStatement, parameter)
+            val parameterName = determineParameterName(clazz, parameter)
+            nonPrimitiveMocked = addMissingUseStatements.invoke(namespace, parameterClassName, aliasedUseStatementList[parameterClassName]) || nonPrimitiveMocked
+            addMockAssignment.invoke(project, constructStatement, parameter, parameterName)
 
-            currentAnchor = addProperty.invoke(project, parameter, currentAnchor, clazz, settings.addDocBlockForMembers)
+            currentAnchor = addProperty.invoke(project, parameter, parameterName, currentAnchor, clazz, settings.addDocBlockForMembers)
+
+            parameterMapByName.add(Pair(parameterName, parameter))
         }
 
         if (settings.addDocBlockForMembers && nonPrimitiveMocked) {
@@ -78,7 +82,11 @@ class QuickMockCreator : PsiElementBaseIntentionAction(), IntentionAction {
 
         addNewlineBefore.invoke(constructStatement, project)
         removeSurroundingWhitespaces.invoke(parameterList)
-        addArguments.invoke(parameterList, allParameters, project)
+        addArguments.invoke(parameterList, parameterMapByName, project)
         reformatTestcase.invoke(project, currentAnchor, clazz)
     }
+
+    private fun determineParameterName(clazz: PhpClass, parameter: Parameter): String {
+        return if (clazz.findOwnFieldByName(parameter.name, false) == null && clazz.findFieldByName(parameter.name, false) != null) parameter.name + GENERATED_SUFFIX else parameter.name
+    }
 }

src/main/kotlin/de/cawolf/quickmock/intention/service/AddArguments.kt

@@ -11,9 +11,9 @@ import com.jetbrains.php.lang.psi.visitors.PhpElementVisitor
 import de.cawolf.quickmock.intention.PRIMITIVES
 
 class AddArguments {
-    fun invoke(parameterList: PsiElement, parameter: MutableList<Parameter>, project: Project) {
-        val parameterListType = IElementType.enumerate { it -> it.toString() == "Parameter list" }.first()
-        val joinedParameterValues = parameter.joinToString { it -> "\$this->${it.name}${addReveal(it)}" }
+    fun invoke(parameterList: PsiElement, parameter: List<Pair<String, Parameter>>, project: Project) {
+        val parameterListType = IElementType.enumerate { it.toString() == "Parameter list" }.first()
+        val joinedParameterValues = parameter.joinToString { "\$this->${it.first}${addReveal(it.second)}" }
         val newParameterList = createFirstFromText(project, parameterListType, "f($joinedParameterValues);")
         parameterList.replace(newParameterList)
     }

src/main/kotlin/de/cawolf/quickmock/intention/service/AddMockAssignment.kt

@@ -7,11 +7,11 @@ import com.jetbrains.php.lang.psi.PhpPsiElementFactory
 import com.jetbrains.php.lang.psi.elements.Parameter
 
 class AddMockAssignment {
-    fun invoke(project: Project, constructStatement: PsiElement, parameter: Parameter) {
-        val whitespaceType = IElementType.enumerate { it -> it.toString() == "WHITE_SPACE" }.first()
+    fun invoke(project: Project, constructStatement: PsiElement, parameter: Parameter, parameterName: String) {
+        val whitespaceType = IElementType.enumerate { it.toString() == "WHITE_SPACE" }.first()
         val mockAssignment = PhpPsiElementFactory.createStatement(
                 project,
-                "\$this->${parameter.name} = ${mockValueFromType(parameter)};"
+                "\$this->$parameterName = ${mockValueFromType(parameter)};"
         )
 
         val currentMethod = constructStatement.parent

src/main/kotlin/de/cawolf/quickmock/intention/service/AddProperty.kt

@@ -9,11 +9,11 @@ import com.jetbrains.php.lang.psi.elements.PhpClass
 import de.cawolf.quickmock.intention.PRIMITIVES
 
 class AddProperty {
-    fun invoke(project: Project, parameter: Parameter, currentAnchor: PsiElement, clazz: PhpClass, addDocBlockForMembers: Boolean): PsiElement {
-        val classFieldsType = IElementType.enumerate { it -> it.toString() == "Class fields" }.first()
-        val docCommentType = IElementType.enumerate { it -> it.toString() == "PhpDocComment" }.first()
+    fun invoke(project: Project, parameter: Parameter, parameterName: String, currentAnchor: PsiElement, clazz: PhpClass, addDocBlockForMembers: Boolean): PsiElement {
+        val classFieldsType = IElementType.enumerate { it.toString() == "Class fields" }.first()
+        val docCommentType = IElementType.enumerate { it.toString() == "PhpDocComment" }.first()
 
-        val field = PhpPsiElementFactory.createFromText(project, classFieldsType, "class C { private \$${parameter.name}; }")
+        val field = PhpPsiElementFactory.createFromText(project, classFieldsType, "class C { private \$$parameterName; }")
         val fieldAnchor = clazz.addAfter(field, currentAnchor)
 
         if (addDocBlockForMembers) {

src/main/kotlin/de/cawolf/quickmock/intention/service/ExistingMocks.kt

@@ -1,11 +1,18 @@
 package de.cawolf.quickmock.intention.service
 
+import com.jetbrains.php.lang.psi.elements.Field
 import com.jetbrains.php.lang.psi.elements.Parameter
 import com.jetbrains.php.lang.psi.elements.PhpClass
+import de.cawolf.quickmock.intention.GENERATED_SUFFIX
 
 class ExistingMocks {
     fun filter(parameter: Parameter, clazz: PhpClass): Boolean {
-        val existingField = clazz.findFieldByName(parameter.name, false)
+        val existingField = clazz.findOwnFieldByName(parameter.name, false)
+        val existingSuffixedField = clazz.findOwnFieldByName(parameter.name + GENERATED_SUFFIX, false)
+        return notMocked(existingField) || notMocked(existingSuffixedField)
+    }
+
+    private fun notMocked(existingField: Field?): Boolean {
         val isPrivate = existingField?.modifier?.isPrivate
         return isPrivate == null || !isPrivate
     }