Play around with eex style plugin

src/main/kotlin/com/mwnciau/rblade/RBladeFileViewProvider.kt

@@ -9,29 +9,34 @@ import com.intellij.psi.MultiplePsiFilesPerDocumentFileViewProvider
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiManager
 import com.intellij.psi.impl.source.PsiFileImpl
+import com.intellij.psi.templateLanguages.ConfigurableTemplateLanguageFileViewProvider
 import com.intellij.psi.templateLanguages.TemplateDataElementType
 import com.intellij.psi.templateLanguages.TemplateLanguageFileViewProvider
+import com.intellij.psi.tree.IElementType
 import com.mwnciau.rblade.psi.RBladeFile
 import com.mwnciau.rblade.psi.RBladeOuterElementType
 import com.mwnciau.rblade.psi.RBladeTypes
 import org.jetbrains.plugins.ruby.ruby.lang.RubyLanguage
+import java.util.concurrent.ConcurrentHashMap
 
 
 class RBladeFileViewProvider(
   manager: PsiManager,
   virtualFile: VirtualFile,
   eventSystemEnabled: Boolean
-) : MultiplePsiFilesPerDocumentFileViewProvider(manager, virtualFile, eventSystemEnabled), TemplateLanguageFileViewProvider {
+) : MultiplePsiFilesPerDocumentFileViewProvider(manager, virtualFile, eventSystemEnabled),
+  ConfigurableTemplateLanguageFileViewProvider {
   companion object {
-    val OUTER_RBLADE = RBladeOuterElementType("Outer RBlade");
+    val OUTER_RBLADE = RBladeOuterElementType("Outer RBlade")
+    val ELEMENT_TYPE_BY_LANGUAGE_ID = ConcurrentHashMap<String, IElementType>();
   }
 
   override fun getBaseLanguage(): Language {
     return RBladeLanguage.INSTANCE
   }
 
   override fun getLanguages(): MutableSet<Language> {
-    return mutableSetOf(RBladeLanguage.INSTANCE, HTMLLanguage.INSTANCE/*, RubyLanguage.INSTANCE*/)
+    return mutableSetOf(RBladeLanguage.INSTANCE, HTMLLanguage.INSTANCE, RubyLanguage.INSTANCE)
   }
 
   override fun getTemplateDataLanguage(): Language {
@@ -43,20 +48,51 @@ class RBladeFileViewProvider(
   }
 
   override fun createFile(lang: Language): PsiFile? {
-    if (lang === RBladeLanguage.INSTANCE) {
+    /*if (lang === RBladeLanguage.INSTANCE) {
       return RBladeFile(this)
-    }
+    }*/
 
     val parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(lang) ?: return null
 
-    val psiFile = parserDefinition.createFile(this)
+    if (lang.isKindOf(RBladeLanguage.INSTANCE)) {
+      return parserDefinition.createFile(this)
+    }
+
+    val psiFileImpl = parserDefinition.createFile(this) as PsiFileImpl
+    psiFileImpl.contentElementType = elementType(lang)
+
+    return psiFileImpl
+    /*val psiFile = parserDefinition.createFile(this)
     if (lang === HTMLLanguage.INSTANCE && psiFile is PsiFileImpl) {
       psiFile.contentElementType = TemplateDataElementType("HTML embedded in RBlade", RBladeLanguage.INSTANCE, RBladeTypes.HTML_TEMPLATE, OUTER_RBLADE)
     }/* else if (lang === RubyLanguage.INSTANCE && psiFile is PsiFileImpl) {
       psiFile.contentElementType = TemplateDataElementType("Ruby embedded in RBlade", RBladeLanguage.INSTANCE, RBladeTypes.RUBY_TEMPLATE, OUTER_RBLADE)
       //return LanguageParserDefinitions.INSTANCE.forLanguage(RubyLanguage.INSTANCE).createFile(this) as PsiFileImpl;
     }*/
 
-    return psiFile
+    return psiFile*/
+  }
+
+  fun elementType(lang : Language) : IElementType {
+    return ELEMENT_TYPE_BY_LANGUAGE_ID.computeIfAbsent(
+      lang.getID(),
+      {
+        languageID : String ->
+          val elementType : IElementType
+
+          /*if (language == RubyLanguage.INSTANCE) {
+              elementType = EmbeddedElixir();
+          } else {
+              elementType = new TemplateData(language);
+          }*/
+          elementType = TemplateData(language)
+
+          elementType
+      }
+    )
+  }
+
+  override fun supportsIncrementalReparse(rootLanguage: Language): Boolean {
+    return false
   }
 }

src/main/kotlin/com/mwnciau/rblade/psi/HtmlElementType.kt

@@ -0,0 +1,15 @@
+package com.mwnciau.rblade.psi
+
+import com.intellij.lang.Language
+import com.intellij.lang.html.HTMLLanguage
+import com.intellij.psi.templateLanguages.TemplateDataElementType
+import com.intellij.psi.tree.IElementType
+import org.jetbrains.annotations.NonNls
+
+class HtmlElementType : TemplateDataElementType(
+  "HTML_TEMPLATE",
+  HTMLLanguage.INSTANCE,
+  RBladeTypes.HTML_TEMPLATE
+  outerElementType,
+) {
+}

src/main/kotlin/com/mwnciau/rblade/psi/RBladeTokenSets.kt

@@ -4,6 +4,6 @@ import com.intellij.psi.tree.TokenSet
 
 interface RBladeTokenSets {
     companion object {
-        val COMMENTS: TokenSet = TokenSet.create(RBladeTypes.COMMENT, RBladeTypes.RUBY_EXPRESSION)
+        val COMMENTS: TokenSet = TokenSet.create(RBladeTypes.COMMENT)
     }
 }

src/main/kotlin/com/mwnciau/rblade/rails/RubyRBladeIntegrationImpl.kt

@@ -0,0 +1,73 @@
+package com.mwnciau.rblade.rails
+
+import com.intellij.lang.Language
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.fileTypes.FileType
+import com.intellij.psi.FileViewProvider
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.tree.IElementType
+import org.jetbrains.plugins.ruby.ruby.lang.psi.controlStructures.blocks.RCompoundStatement
+import org.jetbrains.plugins.ruby.ruby.lang.psi.expressions.RExpression
+import org.jetbrains.plugins.ruby.templates.TemplateIntegration
+import org.jetbrains.plugins.ruby.templates.TemplateIntegrationUtils
+
+class RubyRBladeIntegrationImpl : TemplateIntegration {
+  override fun getOuterElements(): MutableCollection<out IElementType> {
+    TODO("Not yet implemented")
+  }
+
+  override fun getContinuationElements(): MutableCollection<out IElementType> {
+    TODO("Not yet implemented")
+  }
+
+  override fun getEndElements(): MutableCollection<out IElementType> {
+    TODO("Not yet implemented")
+  }
+
+  override fun isTemplateFile(p0: PsiFile?): Boolean {
+    TODO("Not yet implemented")
+  }
+
+  override fun canModifyPsiInsert(p0: FileViewProvider): Boolean {
+    TODO("Not yet implemented")
+  }
+
+  override fun addRubyStatement(
+    p0: FileViewProvider,
+    p1: RCompoundStatement,
+    p2: PsiElement,
+    p3: PsiElement?,
+    p4: Boolean
+  ): PsiElement? {
+    TODO("Not yet implemented")
+  }
+
+  override fun getFileType(p0: TemplateIntegrationUtils.TemplateLang): FileType? {
+    TODO("Not yet implemented")
+  }
+
+  override fun getFileType(): FileType {
+    TODO("Not yet implemented")
+  }
+
+  override fun getTemplateLanguage(): TemplateIntegrationUtils.TemplateLang {
+    TODO("Not yet implemented")
+  }
+
+  override fun getLanguage(): Language {
+    TODO("Not yet implemented")
+  }
+
+  override fun getTextForI18n(p0: Editor, p1: PsiFile): String? {
+    TODO("Not yet implemented")
+  }
+
+  override fun replaceTextWithI18n(p0: Editor, p1: PsiFile, p2: RExpression): Boolean {
+    TODO("Not yet implemented")
+  }
+
+  override fun mustCloseRubyBlock(): Boolean {
+    TODO("Not yet implemented")
+  }
+}

src/main/resources/META-INF/plugin.xml

@@ -50,9 +50,6 @@
         <lang.inspectionSuppressor
             language="HTML"
             implementationClass="com.mwnciau.rblade.inspections.HtmlInspectionSuppressor"/>
-        <languageInjectionContributor
-            language="RBlade"
-            implementationClass="com.mwnciau.rblade.injection.RubyLanguageInjectorContributor"/>
 
         <internalFileTemplate name="Rblade File"/>
     </extensions>