Merge pull request #287 from koxudaxi/fix_format

Fix format
koxudaxi · May 3, 2021 · 28abc47 · 28abc47
2 parents a2bb9cd + 8eb041f
commit 28abc47
Show file tree

Hide file tree

Showing 35 changed files with 1,061 additions and 823 deletions.
diff --git a/resources/META-INF/plugin.xml b/resources/META-INF/plugin.xml
@@ -7,6 +7,7 @@
     <h2>version 0.3.1</h2>
     <p>Features</p>
     <ul>
+        <li>Fix format [#287]</li>
         <li>Improve handling pydantic version [#286]</li>
         <li>Support config parameters on class kwargs [#285]</li>
     </ul>

diff --git a/src/com/koxudaxi/pydantic/Pydantic.kt b/src/com/koxudaxi/pydantic/Pydantic.kt
@@ -13,11 +13,14 @@ import com.jetbrains.extensions.QNameResolveContext
 import com.jetbrains.extensions.resolveToElement
 import com.jetbrains.python.codeInsight.typing.PyTypingTypeProvider
 import com.jetbrains.python.psi.*
-import com.jetbrains.python.psi.impl.*
+import com.jetbrains.python.psi.impl.PyStarArgumentImpl
+import com.jetbrains.python.psi.impl.PyTargetExpressionImpl
 import com.jetbrains.python.psi.resolve.PyResolveContext
 import com.jetbrains.python.psi.resolve.PyResolveUtil
 import com.jetbrains.python.psi.types.*
-import com.jetbrains.python.sdk.*
+import com.jetbrains.python.sdk.PythonSdkUtil
+import com.jetbrains.python.sdk.isAssociatedWithModule
+import com.jetbrains.python.sdk.pythonSdk
 import com.jetbrains.python.statistics.modules
 import java.util.regex.Pattern
 
@@ -348,7 +351,12 @@ fun validateConfig(pyClass: PyClass): List<PsiElement>? {
     return results
 }
 
-fun getConfig(pyClass: PyClass, context: TypeEvalContext, setDefault: Boolean, pydanticVersion: KotlinVersion? = null): HashMap<String, Any?> {
+fun getConfig(
+    pyClass: PyClass,
+    context: TypeEvalContext,
+    setDefault: Boolean,
+    pydanticVersion: KotlinVersion? = null,
+): HashMap<String, Any?> {
     val config = hashMapOf<String, Any?>()
     val version = pydanticVersion ?: PydanticVersionService.getVersion(pyClass.project, context)
     pyClass.getAncestorClasses(context)

diff --git a/src/com/koxudaxi/pydantic/PydanticAnnotator.kt b/src/com/koxudaxi/pydantic/PydanticAnnotator.kt
@@ -20,15 +20,20 @@ class PydanticAnnotator : PyAnnotator() {
     private fun annotatePydanticModelCallableExpression(pyCallExpression: PyCallExpression) {
         val context = TypeEvalContext.userInitiated(pyCallExpression.project, pyCallExpression.containingFile)
         val pyClass = getPydanticPyClass(pyCallExpression, context) ?: return
-        val unFilledArguments = getPydanticUnFilledArguments(pyClass, pyCallExpression, pydanticTypeProvider, context).nullize()
+        val unFilledArguments =
+            getPydanticUnFilledArguments(pyClass, pyCallExpression, pydanticTypeProvider, context).nullize()
                 ?: return
-        holder.newSilentAnnotation(HighlightSeverity.INFORMATION).withFix(PydanticInsertArgumentsQuickFix(false)).create()
+        holder.newSilentAnnotation(HighlightSeverity.INFORMATION).withFix(PydanticInsertArgumentsQuickFix(false))
+            .create()
         unFilledArguments.filter { it.required }.nullize() ?: return
         val highlight = when {
-            isSubClassOfBaseSetting(pyClass, context) || pyCallExpression.arguments.any {(it as? PyStarArgument)?.isKeyword == true} -> HighlightSeverity.INFORMATION
+            isSubClassOfBaseSetting(pyClass,
+                context) || pyCallExpression.arguments.any { (it as? PyStarArgument)?.isKeyword == true } -> HighlightSeverity.INFORMATION
             else -> HighlightSeverity.WARNING
         }
-        holder.newSilentAnnotation(highlight).withFix(PydanticInsertArgumentsQuickFix(true)).range(TextRange.from(pyCallExpression.textOffset + pyCallExpression.textLength  - 1,1)).create()
-        holder.newSilentAnnotation(HighlightSeverity.INFORMATION).withFix(PydanticInsertArgumentsQuickFix(true)).range(TextRange.from(pyCallExpression.textOffset,pyCallExpression.textLength  - 2)).create()
+        holder.newSilentAnnotation(highlight).withFix(PydanticInsertArgumentsQuickFix(true))
+            .range(TextRange.from(pyCallExpression.textOffset + pyCallExpression.textLength - 1, 1)).create()
+        holder.newSilentAnnotation(HighlightSeverity.INFORMATION).withFix(PydanticInsertArgumentsQuickFix(true))
+            .range(TextRange.from(pyCallExpression.textOffset, pyCallExpression.textLength - 2)).create()
     }
 }
diff --git a/src/com/koxudaxi/pydantic/PydanticCompletionContributor.kt b/src/com/koxudaxi/pydantic/PydanticCompletionContributor.kt
diff --git a/src/com/koxudaxi/pydantic/PydanticConfigPanel.java b/src/com/koxudaxi/pydantic/PydanticConfigPanel.java
@@ -16,6 +16,12 @@
 
 public class PydanticConfigPanel {
 
+    private JPanel configPanel;
+    private JCheckBox initTypedCheckBox;
+    private JTextPane ifEnabledIncludeTheTextPane;
+    private JCheckBox warnUntypedFieldsCheckBox;
+    private JTextPane ifEnabledRaiseATextPane;
+    private JTextPane textPane1;
     PydanticConfigPanel(Project project) {
         PydanticConfigService pydanticConfigService = PydanticConfigService.Companion.getInstance(project);
 
@@ -33,13 +39,6 @@ public class PydanticConfigPanel {
         setHyperlinkHtml(this.textPane1, "See <a href=\"https://koxudaxi.github.io/pydantic-pycharm-plugin/\">documentation</a> for more details.</p>");
     }
 
-    private JPanel configPanel;
-    private JCheckBox initTypedCheckBox;
-    private JTextPane ifEnabledIncludeTheTextPane;
-    private JCheckBox warnUntypedFieldsCheckBox;
-    private JTextPane ifEnabledRaiseATextPane;
-    private JTextPane textPane1;
-
     public Boolean getInitTyped() {
         return initTypedCheckBox.isSelected();
     }

diff --git a/src/com/koxudaxi/pydantic/PydanticConfigurable.kt b/src/com/koxudaxi/pydantic/PydanticConfigurable.kt
@@ -25,7 +25,7 @@ class PydanticConfigurable internal constructor(project: Project) : Configurable
 
     override fun isModified(): Boolean {
         if (configPanel.initTyped == null || configPanel.warnUntypedFields == null) return false
-        return  (pydanticConfigService.initTyped != configPanel.initTyped) ||
+        return (pydanticConfigService.initTyped != configPanel.initTyped) ||
                 (pydanticConfigService.warnUntypedFields != configPanel.warnUntypedFields)
     }
 

diff --git a/src/com/koxudaxi/pydantic/PydanticDataclassTypeProvider.kt b/src/com/koxudaxi/pydantic/PydanticDataclassTypeProvider.kt
@@ -3,7 +3,8 @@ package com.koxudaxi.pydantic
 import com.intellij.psi.PsiElement
 import com.jetbrains.python.codeInsight.stdlib.PyDataclassTypeProvider
 import com.jetbrains.python.psi.*
-import com.jetbrains.python.psi.impl.*
+import com.jetbrains.python.psi.impl.PyCallExpressionImpl
+import com.jetbrains.python.psi.impl.PyCallExpressionNavigator
 import com.jetbrains.python.psi.types.*
 
 /**

diff --git a/src/com/koxudaxi/pydantic/PydanticDynamicModel.kt b/src/com/koxudaxi/pydantic/PydanticDynamicModel.kt
@@ -11,9 +11,11 @@ import com.jetbrains.python.psi.types.PyCallableParameter
 import com.jetbrains.python.psi.types.PyClassLikeType
 import com.jetbrains.python.psi.types.TypeEvalContext
 
-class PydanticDynamicModel(astNode: ASTNode, val baseModel: PyClass, val attributes: Map<String, Attribute>) : PyClassImpl(astNode) {
-    val members: List<PyCustomMember> =  attributes.values.map { it.pyCustomMember }
-    private val memberResolver: Map<String, PyElement> = attributes.entries.filterNot { it.value.isInAncestor } .associate { it.key to it.value.pyElement }
+class PydanticDynamicModel(astNode: ASTNode, val baseModel: PyClass, val attributes: Map<String, Attribute>) :
+    PyClassImpl(astNode) {
+    val members: List<PyCustomMember> = attributes.values.map { it.pyCustomMember }
+    private val memberResolver: Map<String, PyElement> =
+        attributes.entries.filterNot { it.value.isInAncestor }.associate { it.key to it.value.pyElement }
 
     fun resolveMember(name: String): PyElement? = memberResolver[name]
 
@@ -22,17 +24,29 @@ class PydanticDynamicModel(astNode: ASTNode, val baseModel: PyClass, val attribu
             mutableListOf(it)
         } ?: mutableListOf()
     }
-    data class Attribute(val pyCallableParameter: PyCallableParameter, val pyCustomMember: PyCustomMember, val pyElement: PyElement, val isInAncestor: Boolean)
+
+    data class Attribute(
+        val pyCallableParameter: PyCallableParameter,
+        val pyCustomMember: PyCustomMember,
+        val pyElement: PyElement,
+        val isInAncestor: Boolean,
+    )
 
     companion object {
-        fun createAttribute(name: String, parameter: PyCallableParameter, originalPyExpression: PyExpression, context: TypeEvalContext, isInAncestor: Boolean): Attribute {
+        fun createAttribute(
+            name: String,
+            parameter: PyCallableParameter,
+            originalPyExpression: PyExpression,
+            context: TypeEvalContext,
+            isInAncestor: Boolean,
+        ): Attribute {
             val type = parameter.getType(context)
             return Attribute(parameter,
-                    PyCustomMember(name, null) { type }
+                PyCustomMember(name, null) { type }
                     .toPsiElement(originalPyExpression)
                     .withIcon(AllIcons.Nodes.Field),
-                    originalPyExpression,
-                    isInAncestor
+                originalPyExpression,
+                isInAncestor
             )
         }
     }

diff --git a/src/com/koxudaxi/pydantic/PydanticDynamicModelMemberProvider.kt b/src/com/koxudaxi/pydantic/PydanticDynamicModelMemberProvider.kt
@@ -3,19 +3,30 @@ package com.koxudaxi.pydantic
 import com.intellij.psi.PsiElement
 import com.jetbrains.python.codeInsight.PyCustomMember
 import com.jetbrains.python.psi.resolve.PyResolveContext
-import com.jetbrains.python.psi.types.*
+import com.jetbrains.python.psi.types.PyClassMembersProviderBase
+import com.jetbrains.python.psi.types.PyClassType
+import com.jetbrains.python.psi.types.TypeEvalContext
 
 class PydanticDynamicModelMemberProvider : PyClassMembersProviderBase() {
-    override fun resolveMember(type: PyClassType, name: String, location: PsiElement?, resolveContext: PyResolveContext): PsiElement? {
-        val pyClass =  type.pyClass
+    override fun resolveMember(
+        type: PyClassType,
+        name: String,
+        location: PsiElement?,
+        resolveContext: PyResolveContext,
+    ): PsiElement? {
+        val pyClass = type.pyClass
         if (pyClass is PydanticDynamicModel && !type.isDefinition)
             pyClass.resolveMember(name)?.let { return it }
         return super.resolveMember(type, name, location, resolveContext)
     }
 
-    override fun getMembers(clazz: PyClassType?, location: PsiElement?, context: TypeEvalContext): MutableCollection<PyCustomMember> {
+    override fun getMembers(
+        clazz: PyClassType?,
+        location: PsiElement?,
+        context: TypeEvalContext,
+    ): MutableCollection<PyCustomMember> {
         if (clazz == null || clazz.isDefinition) return mutableListOf()
-        val pyClass =  clazz.pyClass
+        val pyClass = clazz.pyClass
         return if (pyClass is PydanticDynamicModel) {
             pyClass.members.toMutableList()
         } else {

diff --git a/src/com/koxudaxi/pydantic/PydanticFieldRenameFactory.kt b/src/com/koxudaxi/pydantic/PydanticFieldRenameFactory.kt
@@ -23,7 +23,8 @@ class PydanticFieldRenameFactory : AutomaticRenamerFactory {
                 if (isPydanticModel(pyClass, true)) return true
             }
             is PyKeywordArgument -> {
-                val pyClass = getPyClassByPyKeywordArgument(element, TypeEvalContext.codeAnalysis(element.project, element.containingFile)) ?: return false
+                val pyClass = getPyClassByPyKeywordArgument(element,
+                    TypeEvalContext.codeAnalysis(element.project, element.containingFile)) ?: return false
                 if (isPydanticModel(pyClass, true)) return true
             }
         }
@@ -53,17 +54,18 @@ class PydanticFieldRenameFactory : AutomaticRenamerFactory {
                 is PyTargetExpression ->
                     element.name?.let { name ->
                         element.containingClass
-                                ?.let { pyClass ->
-                                    addAllElement(pyClass, name, added)
-                                }
+                            ?.let { pyClass ->
+                                addAllElement(pyClass, name, added)
+                            }
                         suggestAllNames(name, newName)
                     }
                 is PyKeywordArgument ->
                     element.name?.let { name ->
-                        getPyClassByPyKeywordArgument(element, TypeEvalContext.userInitiated(element.project, element.containingFile))
-                                ?.let { pyClass ->
-                                    addAllElement(pyClass, name, added)
-                                }
+                        getPyClassByPyKeywordArgument(element,
+                            TypeEvalContext.userInitiated(element.project, element.containingFile))
+                            ?.let { pyClass ->
+                                addAllElement(pyClass, name, added)
+                            }
                         suggestAllNames(name, newName)
                     }
             }
@@ -74,12 +76,12 @@ class PydanticFieldRenameFactory : AutomaticRenamerFactory {
             addClassAttributes(pyClass, elementName)
             addKeywordArguments(pyClass, elementName)
             pyClass.getAncestorClasses(null)
-                    .filter { isPydanticModel(it, true) && !added.contains(it) }
-                    .forEach { addAllElement(it, elementName, added) }
+                .filter { isPydanticModel(it, true) && !added.contains(it) }
+                .forEach { addAllElement(it, elementName, added) }
 
             PyClassInheritorsSearch.search(pyClass, true)
-                    .filterNot { added.contains(it) }
-                    .forEach { addAllElement(it, elementName, added) }
+                .filterNot { added.contains(it) }
+                .forEach { addAllElement(it, elementName, added) }
         }
 
         private fun addClassAttributes(pyClass: PyClass, elementName: String) {
@@ -90,12 +92,12 @@ class PydanticFieldRenameFactory : AutomaticRenamerFactory {
         private fun addKeywordArguments(pyClass: PyClass, elementName: String) {
             ReferencesSearch.search(pyClass as PsiElement).forEach { psiReference ->
                 PsiTreeUtil.getParentOfType(psiReference.element, PyCallExpression::class.java)
-                        ?.let { callee ->
-                            callee.arguments
-                                    .filterIsInstance<PyKeywordArgument>()
-                                    .filter { it.name == elementName }
-                                    .forEach { myElements.add(it) }
-                        }
+                    ?.let { callee ->
+                        callee.arguments
+                            .filterIsInstance<PyKeywordArgument>()
+                            .filter { it.name == elementName }
+                            .forEach { myElements.add(it) }
+                    }
             }
         }