Commits

Nerzhul500 committed 92f4d89 Merge

Merge with spellengine_refactoring

Comments (0)

Files changed (34)

ReSpeller.BasicTests/IdentifierSplitterTest.cs

-using System.Collections.Generic;
-using NUnit.Framework;
-using ReSpeller.SpellEngine;
-
-namespace ReSpeller.BasicTests
-{
-  [TestFixture]
-  internal class IdentifierSplitterTest
-  {
-    private static readonly object[] ourCases =
-      {
-        new object[] {"ident", new List<TextPart> {new TextPart("ident", TextPartType.Word, 0, 4)}},
-        new object[]
-          {
-            "newIdent", new List<TextPart>
-                          {
-                            new TextPart("new", TextPartType.Word, 0, 2),
-                            new TextPart("Ident", TextPartType.Word, 3, 7)
-                          }
-          },
-        new object[]
-          {
-            "new123Ident", new List<TextPart>
-                             {
-                               new TextPart("new", TextPartType.Word, 0, 2),
-                               new TextPart("123", TextPartType.NotAWord, 3, 5),
-                               new TextPart("Ident", TextPartType.Word, 6, 10)
-                             }
-          },
-        new object[]
-          {
-            "MyIdent", new List<TextPart>
-                         {
-                           new TextPart("My", TextPartType.Word, 0, 1),
-                           new TextPart("Ident", TextPartType.Word, 2, 6)
-                         }
-          },
-        new object[]
-          {
-            "My123", new List<TextPart>
-                       {
-                         new TextPart("My", TextPartType.Word, 0, 1),
-                         new TextPart("123", TextPartType.NotAWord, 2, 4)
-                       }
-          },
-        new object[] {"Ident", new List<TextPart> {new TextPart("Ident", TextPartType.Word, 0, 4)}},
-        new object[]
-          {
-            "my_ident", new List<TextPart>
-                          {
-                            new TextPart("my", TextPartType.Word, 0, 1),
-                            new TextPart("_", TextPartType.NotAWord, 2, 2),
-                            new TextPart("ident", TextPartType.Word, 3, 7)
-                          }
-          },
-        new object[]
-          {
-            "my_Ident", new List<TextPart>
-                          {
-                            new TextPart("my", TextPartType.Word, 0, 1),
-                            new TextPart("_", TextPartType.NotAWord, 2, 2),
-                            new TextPart("Ident", TextPartType.Word, 3, 7)
-                          }
-          },
-        new object[]
-          {
-            "CAPITAL_ONLY", new List<TextPart>
-                              {
-                                new TextPart("CAPITAL", TextPartType.Word, 0, 6),
-                                new TextPart("_", TextPartType.NotAWord, 7, 7),
-                                new TextPart("ONLY", TextPartType.Word, 8, 11)
-                              }
-          },
-        new object[]
-          {
-            "CAPITAL_andNotONLY", new List<TextPart>
-                                    {
-                                      new TextPart("CAPITAL", TextPartType.Word, 0, 6),
-                                      new TextPart("_", TextPartType.NotAWord, 7, 7),
-                                      new TextPart("and", TextPartType.Word, 8, 10),
-                                      new TextPart("Not", TextPartType.Word, 11, 13),
-                                      new TextPart("ONLY", TextPartType.Word, 14, 17)
-                                    }
-          },
-        new object[]
-          {
-            "FUCKText", new List<TextPart>
-                          {
-                            new TextPart("FUCK", TextPartType.Word, 0, 3),
-                            new TextPart("Text", TextPartType.Word, 4, 7)
-                          }
-          },
-        new object[]
-          {
-            "andFUCKText", new List<TextPart>
-                             {
-                               new TextPart("and", TextPartType.Word, 0, 2),
-                               new TextPart("FUCK", TextPartType.Word, 3, 6),
-                               new TextPart("Text", TextPartType.Word, 7, 10)
-                             }
-          },
-        new object[]
-          {
-            "some Text", new List<TextPart>
-                           {
-                             new TextPart("some", TextPartType.Word, 0, 3),
-                             new TextPart(" ", TextPartType.NotAWord, 4, 4),
-                             new TextPart("Text", TextPartType.Word, 5, 8)
-                           }
-          },
-        new object[]
-          {
-            "he won't do", new List<TextPart>
-                             {
-                               new TextPart("he", TextPartType.Word, 0, 1),
-                               new TextPart(" ", TextPartType.NotAWord, 2, 2),
-                               new TextPart("won't", TextPartType.Word, 3, 7),
-                               new TextPart(" ", TextPartType.NotAWord, 8, 8),
-                               new TextPart("do", TextPartType.Word, 9, 10)
-                             }
-          },
-        new object[]
-          {
-            "he won'", new List<TextPart>
-                         {
-                           new TextPart("he", TextPartType.Word, 0, 1),
-                           new TextPart(" ", TextPartType.NotAWord, 2, 2),
-                           new TextPart("won", TextPartType.Word, 3, 5),
-                           new TextPart("'", TextPartType.NotAWord, 6, 6)
-                         }
-          },
-        new object[]
-          {
-            "he 'won", new List<TextPart>
-                         {
-                           new TextPart("he", TextPartType.Word, 0, 1),
-                           new TextPart(" '", TextPartType.NotAWord, 2, 3),
-                           new TextPart("won", TextPartType.Word, 4, 6)
-                         }
-          }
-      };
-
-    [Test, TestCaseSource("ourCases")]
-    public void SplitTest(string text, List<TextPart> result)
-    {
-      List<TextPart> actual = TextSplitter.Split(text);
-      Assert.AreEqual(result, actual);
-    }
-  }
-}

ReSpeller.BasicTests/ReSpeller.BasicTests.csproj

     </CodeAnalysisDependentAssemblyPaths>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="IdentifierSplitterTest.cs" />
+    <Compile Include="SpellEngine\Dictionaries\UserInternalDictionaryTest.cs" />
+    <Compile Include="SpellEngine\TextSplitterTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SuggestionGeneratorTest.cs" />
+    <Compile Include="SpellEngine\SuggestionGeneratorTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <WCFMetadata Include="Service References\" />
       <Name>ReSpeller</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

ReSpeller.BasicTests/SpellEngine/Dictionaries/UserInternalDictionaryTest.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using ReSpeller.SpellEngine.Dictionaries;
+using Rhino.Mocks;
+
+namespace ReSpeller.BasicTests.SpellEngine.Dictionaries
+{
+  [TestFixture]
+  public class UserInternalDictionaryTest
+  {
+    private IUserInternalDictionary myUserInternalDictionary;
+    private IDictionaryEngine myDictionaryEngine;
+    private IDictionaryStorage myUserStorage;
+    private IDictionaryStorage myInternalStorage;
+    private string myLanguage;
+
+    [SetUp]
+    public void SetUp()
+    {
+      myDictionaryEngine = MockRepository.GenerateMock<IDictionaryEngine>();
+      myUserStorage = MockRepository.GenerateMock<IDictionaryStorage>();
+      myInternalStorage = MockRepository.GenerateMock<IDictionaryStorage>();
+      myLanguage = "en_US";
+      myUserInternalDictionary = new UserInternalDictionary(myDictionaryEngine, myLanguage, myUserStorage, myInternalStorage);
+    }
+
+    [Test]
+    public void TestCheckWord()
+    {
+      myDictionaryEngine.Stub(engine => engine.Check("word")).Repeat.Once().Return(true);
+      myDictionaryEngine.Stub(engine => engine.Check("woard")).Repeat.Once().Return(false);
+      bool correctWord = myUserInternalDictionary.Check("word");
+      Assert.IsTrue(correctWord);
+      bool incorrectWord = myUserInternalDictionary.Check("woard");
+      Assert.IsFalse(incorrectWord);
+      myDictionaryEngine.VerifyAllExpectations();
+    }
+
+    [Test]
+    public void TestAddToUser()
+    {
+      myUserStorage.Stub(storage => storage.AddWord("woard")).Repeat.Once();
+      myDictionaryEngine.Stub(engine => engine.Add("woard")).Repeat.Once();
+      myDictionaryEngine.Stub(engine => engine.Check("woard")).Repeat.Once().Return(true);
+      myUserInternalDictionary.AddToUserDict("woard");
+      bool check = myUserInternalDictionary.Check("woard");
+      Assert.IsTrue(check);
+      myUserStorage.VerifyAllExpectations();
+      myDictionaryEngine.VerifyAllExpectations();
+    }
+
+    [Test]
+    public void TestAddToInternal()
+    {
+      myInternalStorage.Stub(storage => storage.AddWord("woard")).Repeat.Once();
+      myDictionaryEngine.Stub(engine => engine.Add("woard")).Repeat.Once();
+      myDictionaryEngine.Stub(engine => engine.Check("woard")).Repeat.Once().Return(true);
+      myUserInternalDictionary.AddToInternalDict("woard");
+      bool check = myUserInternalDictionary.Check("woard");
+      Assert.IsTrue(check);
+      myInternalStorage.VerifyAllExpectations();
+      myDictionaryEngine.VerifyAllExpectations();
+    }
+
+    [Test]
+    public void TestLanguage()
+    {
+      Assert.AreEqual(myLanguage, myUserInternalDictionary.Language);
+    }
+  }
+}

ReSpeller.BasicTests/SpellEngine/SuggestionGeneratorTest.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using ReSpeller.SpellEngine;
+using Rhino.Mocks;
+
+namespace ReSpeller.BasicTests.SpellEngine
+{
+  /// <summary>
+  /// Summary description for SuggestionGeneratorTest
+  /// </summary>
+  [TestFixture]
+  public class SuggestionGeneratorTest
+  {
+    private readonly ISpellChecker myChecker;
+    private readonly SuggestionGenerator myGenerator;
+
+    public SuggestionGeneratorTest()
+    {
+      myChecker = MockRepository.GenerateStub<ISpellChecker>();
+      myGenerator = new SuggestionGenerator(myChecker);
+      Dictionary<string, string> suggests = new Dictionary<string, string>
+                                              {
+                                                {"idetnifier", "identifier verifier"},
+                                                {"Idetnifier", "identifier verifier"},
+                                                {"my", "my"},
+                                                {"My", "my"},
+                                                {"ixdent", "ident indent"},
+                                                {"Ixdent", "ident indent"},
+                                                {"Sufh", "such much"},
+                                                {"sufh", "such much"},
+                                                {"Fael", "fail fuel fall"},
+                                                {"fael", "fail fuel fall"},
+                                                {"Werd", "ward weird"},
+                                                {"werd", "ward weird"}
+                                              };
+      foreach (var suggest in suggests)
+      {
+        KeyValuePair<string, string> suggest1 = suggest;
+        myChecker.Stub(checker => checker.Suggestions(suggest1.Key)).Return(suggest1.Value.Split(' ').ToList());
+      }
+      Dictionary<string, bool> wordValidity = new Dictionary<string, bool>
+                                                {
+                                                  {"Idetnifier", false},
+                                                  {"idetnifier", false},
+                                                  {"ixdent", false},
+                                                  {"Ixdent", false},
+                                                  {"Sufh", false},
+                                                  {"sufh", false},
+                                                  {"my", true},
+                                                  {"My", true},
+                                                  {"Fael", false},
+                                                  {"Werd", false},
+                                                  {"best", true}
+                                                };
+      foreach (var pair in wordValidity)
+      {
+        KeyValuePair<string, bool> pair1 = pair;
+        myChecker.Stub(checker => checker.CheckWordSpelling(pair1.Key)).Return(pair1.Value);
+      }
+      myGenerator = new SuggestionGenerator(myChecker);
+    }
+
+    [Test]
+    [TestCase("myIdetnifier")]
+    [TestCase("myIdetnifier123Idetnifier")]
+    [TestCase("myIdetnifier123Ixdent")]
+    [TestCase("mySufh123Idetnifier")]
+    [TestCase("bestFaelWerd")]
+    public void SuggestsTest(string s)
+    {
+      var parts = TextSplitter.Split(s);
+      var variants = (from part in parts
+                     select part.Type == TextPartType.NotAWord || myChecker.CheckWordSpelling(part.Text) ?
+                          new List<string> { part.Text } : myChecker.Suggestions(part.Text).Where(s1 => s1.All(Char.IsLetter)).ToList()).
+                          ToList();
+      var expectedCount = variants.Aggregate(1, (i, list) => i * list.Count);
+      var suggests = myGenerator.Generate(s);
+      Assert.AreEqual(expectedCount, suggests.Count);
+    }
+  }
+}

ReSpeller.BasicTests/SpellEngine/TextSplitterTest.cs

+using System.Collections.Generic;
+using NUnit.Framework;
+using ReSpeller.SpellEngine;
+
+namespace ReSpeller.BasicTests.SpellEngine
+{
+  [TestFixture]
+  internal class TextSplitterTest
+  {
+    private static readonly object[] Cases =
+      {
+        new object[] {"ident", new List<TextPart> {new TextPart("ident", TextPartType.Word, 0, 4)}},
+        new object[]
+          {
+            "newIdent", new List<TextPart>
+                          {
+                            new TextPart("new", TextPartType.Word, 0, 2),
+                            new TextPart("Ident", TextPartType.Word, 3, 7)
+                          }
+          },
+        new object[]
+          {
+            "new123Ident", new List<TextPart>
+                             {
+                               new TextPart("new", TextPartType.Word, 0, 2),
+                               new TextPart("123", TextPartType.NotAWord, 3, 5),
+                               new TextPart("Ident", TextPartType.Word, 6, 10)
+                             }
+          },
+        new object[]
+          {
+            "MyIdent", new List<TextPart>
+                         {
+                           new TextPart("My", TextPartType.Word, 0, 1),
+                           new TextPart("Ident", TextPartType.Word, 2, 6)
+                         }
+          },
+        new object[]
+          {
+            "My123", new List<TextPart>
+                       {
+                         new TextPart("My", TextPartType.Word, 0, 1),
+                         new TextPart("123", TextPartType.NotAWord, 2, 4)
+                       }
+          },
+        new object[] {"Ident", new List<TextPart> {new TextPart("Ident", TextPartType.Word, 0, 4)}},
+        new object[]
+          {
+            "my_ident", new List<TextPart>
+                          {
+                            new TextPart("my", TextPartType.Word, 0, 1),
+                            new TextPart("_", TextPartType.NotAWord, 2, 2),
+                            new TextPart("ident", TextPartType.Word, 3, 7)
+                          }
+          },
+        new object[]
+          {
+            "my_Ident", new List<TextPart>
+                          {
+                            new TextPart("my", TextPartType.Word, 0, 1),
+                            new TextPart("_", TextPartType.NotAWord, 2, 2),
+                            new TextPart("Ident", TextPartType.Word, 3, 7)
+                          }
+          },
+        new object[]
+          {
+            "CAPITAL_ONLY", new List<TextPart>
+                              {
+                                new TextPart("CAPITAL", TextPartType.Word, 0, 6),
+                                new TextPart("_", TextPartType.NotAWord, 7, 7),
+                                new TextPart("ONLY", TextPartType.Word, 8, 11)
+                              }
+          },
+        new object[]
+          {
+            "CAPITAL_andNotONLY", new List<TextPart>
+                                    {
+                                      new TextPart("CAPITAL", TextPartType.Word, 0, 6),
+                                      new TextPart("_", TextPartType.NotAWord, 7, 7),
+                                      new TextPart("and", TextPartType.Word, 8, 10),
+                                      new TextPart("Not", TextPartType.Word, 11, 13),
+                                      new TextPart("ONLY", TextPartType.Word, 14, 17)
+                                    }
+          },
+        new object[]
+          {
+            "FUCKText", new List<TextPart>
+                          {
+                            new TextPart("FUCK", TextPartType.Word, 0, 3),
+                            new TextPart("Text", TextPartType.Word, 4, 7)
+                          }
+          },
+        new object[]
+          {
+            "andFUCKText", new List<TextPart>
+                             {
+                               new TextPart("and", TextPartType.Word, 0, 2),
+                               new TextPart("FUCK", TextPartType.Word, 3, 6),
+                               new TextPart("Text", TextPartType.Word, 7, 10)
+                             }
+          },
+        new object[]
+          {
+            "some Text", new List<TextPart>
+                           {
+                             new TextPart("some", TextPartType.Word, 0, 3),
+                             new TextPart(" ", TextPartType.NotAWord, 4, 4),
+                             new TextPart("Text", TextPartType.Word, 5, 8)
+                           }
+          },
+        new object[]
+          {
+            "he won't do", new List<TextPart>
+                             {
+                               new TextPart("he", TextPartType.Word, 0, 1),
+                               new TextPart(" ", TextPartType.NotAWord, 2, 2),
+                               new TextPart("won't", TextPartType.Word, 3, 7),
+                               new TextPart(" ", TextPartType.NotAWord, 8, 8),
+                               new TextPart("do", TextPartType.Word, 9, 10)
+                             }
+          },
+        new object[]
+          {
+            "he won'", new List<TextPart>
+                         {
+                           new TextPart("he", TextPartType.Word, 0, 1),
+                           new TextPart(" ", TextPartType.NotAWord, 2, 2),
+                           new TextPart("won", TextPartType.Word, 3, 5),
+                           new TextPart("'", TextPartType.NotAWord, 6, 6)
+                         }
+          },
+        new object[]
+          {
+            "he 'won", new List<TextPart>
+                         {
+                           new TextPart("he", TextPartType.Word, 0, 1),
+                           new TextPart(" '", TextPartType.NotAWord, 2, 3),
+                           new TextPart("won", TextPartType.Word, 4, 6)
+                         }
+          }
+      };
+
+    [Test, TestCaseSource("Cases")]
+    public void TestTextSplitter(string text, List<TextPart> result)
+    {
+      List<TextPart> actual = TextSplitter.Split(text);
+      Assert.AreEqual(result, actual);
+    }
+  }
+}

ReSpeller.BasicTests/SuggestionGeneratorTest.cs

-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using ReSpeller.SpellEngine;
-using Rhino.Mocks;
-
-namespace ReSpeller.BasicTests
-{
-  /// <summary>
-  /// Summary description for SuggestionGeneratorTest
-  /// </summary>
-  [TestFixture]
-  public class SuggestionGeneratorTest
-  {
-    private readonly ISpellChecker myChecker;
-    private readonly SuggestionGenerator myGenerator;
-
-    public SuggestionGeneratorTest()
-    {
-      myChecker = MockRepository.GenerateStub<ISpellChecker>();
-      myGenerator = new SuggestionGenerator(myChecker);
-      Dictionary<string, string> suggests = new Dictionary<string, string>
-                                              {
-                                                {"idetnifier", "identifier verifier"},
-                                                {"Idetnifier", "identifier verifier"},
-                                                {"my", "my"},
-                                                {"My", "my"},
-                                                {"ixdent", "ident indent"},
-                                                {"Ixdent", "ident indent"},
-                                                {"Sufh", "such much"},
-                                                {"sufh", "such much"},
-                                                {"Fael", "fail fuel fall"},
-                                                {"fael", "fail fuel fall"},
-                                                {"Werd", "ward weird"},
-                                                {"werd", "ward weird"}
-                                              };
-      foreach (var suggest in suggests)
-      {
-        KeyValuePair<string, string> suggest1 = suggest;
-        myChecker.Stub(checker => checker.Suggestions(suggest1.Key)).Return(suggest1.Value.Split(' ').ToList());
-      }
-      Dictionary<string, bool> wordValidity = new Dictionary<string, bool>
-                                                {
-                                                  {"Idetnifier", false},
-                                                  {"idetnifier", false},
-                                                  {"ixdent", false},
-                                                  {"Ixdent", false},
-                                                  {"Sufh", false},
-                                                  {"sufh", false},
-                                                  {"my", true},
-                                                  {"My", true},
-                                                  {"Fael", false},
-                                                  {"Werd", false},
-                                                  {"best", true}
-                                                };
-      foreach (var pair in wordValidity)
-      {
-        KeyValuePair<string, bool> pair1 = pair;
-        myChecker.Stub(checker => checker.CheckWordSpelling(pair1.Key)).Return(pair1.Value);
-      }
-      myGenerator = new SuggestionGenerator(myChecker);
-    }
-
-    [Test]
-    [TestCase("myIdetnifier")]
-    [TestCase("myIdetnifier123Idetnifier")]
-    [TestCase("myIdetnifier123Ixdent")]
-    [TestCase("mySufh123Idetnifier")]
-    [TestCase("bestFaelWerd")]
-    public void SuggestsTest(string s)
-    {
-      var parts = TextSplitter.Split(s);
-      var variants = (from part in parts
-                     select part.Type == TextPartType.NotAWord || myChecker.CheckWordSpelling(part.Text) ?
-                          new List<string> { part.Text } : myChecker.Suggestions(part.Text).Where(s1 => s1.All(Char.IsLetter)).ToList()).
-                          ToList();
-      var expectedCount = variants.Aggregate(1, (i, list) => i * list.Count);
-      var suggests = myGenerator.Generate(s);
-      Assert.AreEqual(expectedCount, suggests.Count);
-    }
-  }
-}

ReSpeller/Actions/AddArbitraryWordHelper.cs

         promptWinForm.FormBorderStyle = FormBorderStyle.FixedDialog;
         if (promptWinForm.ShowDialog())
         {
-          Shell.Instance.GetComponent<SpellChecker>().AddWordToUserDict(promptWinForm.Value);
+          Shell.Instance.GetComponent<ISpellChecker>().AddWordToUserDict(promptWinForm.Value);
         }
       }
     }

ReSpeller/Analyzers/AnalyzerHelper.cs

 {
   static class AnalyzerHelper
   {
-    public static void GenerateRangeBasedHighlightings(SpellChecker checker, IHighlightingConsumer consumer, IFile file, DocumentRange range, 
+    public static void GenerateRangeBasedHighlightings(ISpellChecker checker, IHighlightingConsumer consumer, IFile file, DocumentRange range, 
                                                        Func<DocumentRange, TextRangeTypoHighlighting> highlightingCreator)
     {
       string text = range.GetText();
                                                        string suffix, IDeclaredElement declaredElement,
                                                        bool isNamespace, ITreeNode treeNode)
     {
-      var checker = Shell.Instance.GetComponent<SpellChecker>();
+      var checker = Shell.Instance.GetComponent<ISpellChecker>();
       
       foreach (TextPart p in innerNameParts)
       {

ReSpeller/Analyzers/CommentTypoAnalyzer.cs

   [ElementProblemAnalyzer(new[] { typeof(IComment) })]
   public class CommentTypoAnalyzer : ElementProblemAnalyzer<IComment>
   {
-    private readonly SpellChecker myChecker = Shell.Instance.GetComponent<SpellChecker>();
+    private readonly ISpellChecker myChecker = Shell.Instance.GetComponent<ISpellChecker>();
 
     protected override void Run(IComment element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
     {

ReSpeller/Analyzers/StringLiteralTypoAnalyzer.cs

   [ElementProblemAnalyzer(new[] { typeof(ILiteralExpression) })]
   public class StringLiteralTypoAnalyzer : ElementProblemAnalyzer<ILiteralExpression>
   {
-    private readonly SpellChecker myChecker = Shell.Instance.GetComponent<SpellChecker>();
+    private readonly ISpellChecker myChecker = Shell.Instance.GetComponent<ISpellChecker>();
 
     protected override void Run(ILiteralExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
     {

ReSpeller/Analyzers/XmlTypoAnalysis.cs

 {
   internal class XmlTypoAnalysis : XmlAnalysis
   {
-    private readonly SpellChecker myChecker = Shell.Instance.GetComponent<SpellChecker>();
+    private readonly ISpellChecker myChecker = Shell.Instance.GetComponent<ISpellChecker>();
 
     public override bool InteriorShouldBeProcessed(ITreeNode element)
     {

ReSpeller/Bulbs/AddToDictionaryBulbItem.cs

 
     public void Execute(ISolution solution, ITextControl textControl)
     {
-      var spellChecker = Shell.Instance.GetComponent<SpellChecker>();
+      var spellChecker = Shell.Instance.GetComponent<ISpellChecker>();
       spellChecker.AddWordToUserDict(myNewWord);
       Daemon.GetInstance(solution).Invalidate();
     }

ReSpeller/Bulbs/AddToInternalDictionaryBulbItem.cs

 
     public void Execute(ISolution solution, ITextControl textControl)
     {
-      var spellChecker = Shell.Instance.GetComponent<SpellChecker>();
+      var spellChecker = Shell.Instance.GetComponent<ISpellChecker>();
       spellChecker.AddWordToCustomDict(myNewWord);
       Daemon.GetInstance(solution).Invalidate();
     }

ReSpeller/QuickFixes/TypoQuickFix.cs

   [QuickFix]
   class TypoQuickFix : IQuickFix
   {
-    private readonly SpellChecker myChecker = Shell.Instance.GetComponent<SpellChecker>();
+    private readonly ISpellChecker myChecker = Shell.Instance.GetComponent<ISpellChecker>();
     private readonly SuggestionGenerator mySuggestionGenerator = Shell.Instance.GetComponent<SuggestionGenerator>();
     private readonly IHighlighting myHighlighting;
     private readonly List<IBulbItem> myBulbItems = new List<IBulbItem>();

ReSpeller/ReSpeller.csproj

     <Compile Include="Settings\ReSpellerSettingsControl.xaml.cs">
       <DependentUpon>ReSpellerSettingsControl.xaml</DependentUpon>
     </Compile>
+    <Compile Include="SpellEngine\ConfigurableWordChecker.cs" />
+    <Compile Include="SpellEngine\Constants.cs" />
+    <Compile Include="SpellEngine\Dictionaries\DictionaryFactory.cs" />
+    <Compile Include="SpellEngine\Dictionaries\FileDictionaryStorage.cs" />
+    <Compile Include="SpellEngine\Dictionaries\HunspellEngine.cs" />
+    <Compile Include="SpellEngine\Dictionaries\IDictionaryStorage.cs" />
+    <Compile Include="SpellEngine\Dictionaries\IDictionaryEngine.cs" />
+    <Compile Include="SpellEngine\Dictionaries\ILanguageDictionary.cs" />
     <Compile Include="SpellEngine\ISpellChecker.cs" />
+    <Compile Include="SpellEngine\Dictionaries\IUserInternalDictionary.cs" />
+    <Compile Include="SpellEngine\IWordSuggestor.cs" />
     <Compile Include="SpellEngine\NamingStyleConverter.cs" />
     <Compile Include="SpellEngine\RangeUtils.cs" />
+    <Compile Include="SpellEngine\SingleDictionarySuggestor.cs" />
     <Compile Include="SpellEngine\SpellChecker.cs" />
+    <Compile Include="SpellEngine\SpellCheckerConfig.cs" />
     <Compile Include="SpellEngine\SuggestionGenerator.cs" />
     <Compile Include="SpellEngine\TextSplitter.cs" />
+    <Compile Include="SpellEngine\Dictionaries\UserInternalDictionary.cs" />
+    <Compile Include="Util.cs" />
     <Compile Include="Workflows\ReflectionUtils.cs" />
     <Compile Include="Workflows\RenameNamespaceControlDecorator.cs" />
     <Compile Include="Workflows\RenameNamespaceWorkflowDecorator.cs" />
     <EmbeddedResource Include="Actions.xml" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\dic\custom.dic">
-      <Link>dic\custom.dic</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
     <None Include="..\dic\en_US.aff">
       <Link>dic\en_US.aff</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       <Link>dic\en_US.dic</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="..\dic\en_US_custom.dic">
+      <Link>dic\en_US_custom.dic</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
     </Content>
   </ItemGroup>
   <PropertyGroup>
-    <ReSharperSdkTargets Condition=" '$(ReSharperSdkTargets)' == '' ">$(MSBuildExtensionsPath)\JetBrains\ReSharper.SDK\v7.0</ReSharperSdkTargets>
+    <ReSharperSdkTargets Condition=" '$(ReSharperSdkTargets)' == '' ">$(MSBuildExtensionsPath)\JetBrains\ReSharper.SDK\v7.1</ReSharperSdkTargets>
   </PropertyGroup>
   <Import Project="$(ReSharperSdkTargets)\Plugin.Targets" />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

ReSpeller/Settings/ReSpellerSettingsControl.xaml.cs

 using System.Windows.Controls.Primitives;
+using JetBrains.Application;
 using JetBrains.DataFlow;
 using JetBrains.UI.CrossFramework;
 using JetBrains.UI.Options;
 using JetBrains.UI.Options.OptionPages;
 using JetBrains.Application.Settings;
+using ReSpeller.SpellEngine;
 using Xceed.Wpf.Toolkit;
 
 namespace ReSpeller.Settings
 
     public bool OnOk()
     {
+      var spellChecker = Shell.Instance.GetComponent<ISpellChecker>();
+      spellChecker.UpdateConfig();
       return true;
     }
 

ReSpeller/SpellEngine/ConfigurableWordChecker.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using ReSpeller.SpellEngine.Dictionaries;
+
+namespace ReSpeller.SpellEngine
+{
+  public class ConfigurableWordChecker
+  {
+    private const int MaxLengthForSplit = 30;
+
+    private readonly List<ILanguageDictionary> myDictionaries;
+
+    public ConfigurableWordChecker(List<ILanguageDictionary> dictionaries)
+    {
+      myDictionaries = dictionaries;
+      Config = new SpellCheckerConfig();
+    }
+
+    public SpellCheckerConfig Config { get; set; }
+
+    public bool Check(string word)
+    {
+      if (word.Length < Config.MinWordLength)
+        return true;
+      // try to check in many styles
+      bool wholeWordCheck = CheckInDictionaries(word.ToLower())
+        || CheckInDictionaries(word.ToUpper())
+        || CheckInDictionaries(NamingStyleConverter.Convert(word, "Aaa"));
+      if (wholeWordCheck)
+        return true;
+
+      //try to split into pair of words
+      if (Config.SplitInPairs)
+      {
+        if (word.Length < 4 || word.Length > MaxLengthForSplit) //min size of each word == 2, e.g. inplace -> in+place
+          //also very long words will be ignored
+          return false;
+        for (int i = 2; i < word.Length - 1; ++i)
+        {
+          string first = word.Substring(0, i);
+          string second = word.Substring(i);
+          if (CheckInDictionaries(first) && CheckInDictionaries(second))
+            return true;
+        }
+      }
+      return false;
+    }
+
+    private bool CheckInDictionaries(string word)
+    {
+      return myDictionaries.Any(dictionary => dictionary.Check(word));
+    }    
+  }
+}

ReSpeller/SpellEngine/Constants.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ReSpeller.SpellEngine
+{
+  static class Constants
+  {
+    public const string DictExt = "dic";
+    public const string InternalDictSuffix = "_custom";
+    public const string MainDictSubDir = "dic";
+    public const string UserDictSubDir = "ReSpeller";
+    public const string HunspellAffixExt = "aff";
+    public const string HunspellDictExt = "dic";
+  }
+}

ReSpeller/SpellEngine/Dictionaries/DictionaryFactory.cs

+using System;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public interface IDictionaryFactory
+  {
+    ILanguageDictionary CreateDictionary(string language);
+  }
+
+  public class HunspellDictionaryFactory : IDictionaryFactory
+  {
+    private readonly string myMainDictionariesDir;
+    private readonly string myUserDictionariesDir;
+
+
+    public HunspellDictionaryFactory(string mainDictionariesDir, string userDictionariesDir)
+    {
+      myMainDictionariesDir = mainDictionariesDir;
+      myUserDictionariesDir = userDictionariesDir;
+    }
+
+    public ILanguageDictionary CreateDictionary(string language)
+    {
+      throw new NotImplementedException();
+    }
+  }
+}

ReSpeller/SpellEngine/Dictionaries/FileDictionaryStorage.cs

+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using JetBrains.Util;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public class FileDictionaryStorage : IDictionaryStorage
+  {
+    private readonly string myFileName;
+
+    public FileDictionaryStorage(string fileName)
+    {
+      myFileName = fileName;
+      if (!File.Exists(fileName))
+      {
+        string directoryName = Path.GetDirectoryName(fileName);
+        if (!Directory.Exists(directoryName))
+          Directory.CreateDirectory(directoryName);
+        File.Create(fileName).Dispose();
+      }
+        
+    }
+
+    public void AddWord(string word)
+    {
+      var content = new HashSet<string>();
+      if (File.Exists(myFileName))
+      {
+        string[] lines = File.ReadAllLines(myFileName); 
+        content.AddRange(lines);
+      }
+      content.Add(word.ToLower());
+      File.WriteAllLines(myFileName, content.ToArray());
+    }
+
+    public List<string> GetContent()
+    {
+      string[] lines = File.ReadAllLines(myFileName);
+      return lines.ToList();
+    }
+  }
+}

ReSpeller/SpellEngine/Dictionaries/HunspellEngine.cs

+using System.Collections.Generic;
+using System.IO;
+using NHunspell;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public class HunspellEngine : IDictionaryEngine
+  {
+    private readonly Hunspell myHunspell;
+
+    public static string NativeDllPath
+    {
+      get { return Hunspell.NativeDllPath; }
+      set { Hunspell.NativeDllPath = value; }
+    }
+
+    public HunspellEngine(string affixFile, string dictFile)
+    {
+      myHunspell = new Hunspell(affixFile, dictFile);
+    }
+
+    public bool Check(string word)
+    {
+      return myHunspell.Spell(word);
+    }
+
+    public List<string> Suggest(string word)
+    {
+      return myHunspell.Suggest(word);
+    }
+
+    public void Add(string word)
+    {
+      myHunspell.Add(word);
+    }
+
+    public void AddRange(IEnumerable<string> words)
+    {
+      foreach (var word in words)
+      {
+        myHunspell.Add(word);
+      }
+    }
+
+    public void Dispose()
+    {
+      if (myHunspell != null && !myHunspell.IsDisposed)
+        myHunspell.Dispose();
+    }
+
+    public static HunspellEngine CreateForLanguage(string dictDir, string language)
+    {
+      string dictFile = Path.Combine(dictDir, language + "." + Constants.HunspellDictExt);
+      string affixFile = Path.Combine(dictDir, language + "." + Constants.HunspellAffixExt);
+      return new HunspellEngine(affixFile, dictFile);
+    }
+  }
+}

ReSpeller/SpellEngine/Dictionaries/IDictionaryEngine.cs

+using System;
+using System.Collections.Generic;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public interface IDictionaryEngine : IDisposable
+  {
+    bool Check(string word);
+    List<string> Suggest(string word);
+    void Add(string word);
+    void AddRange(IEnumerable<string> words);
+  }
+}

ReSpeller/SpellEngine/Dictionaries/IDictionaryStorage.cs

+using System.Collections.Generic;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public interface IDictionaryStorage
+  {
+    void AddWord(string word);
+    List<string> GetContent();
+  }
+}

ReSpeller/SpellEngine/Dictionaries/ILanguageDictionary.cs

+using System;
+using System.Collections.Generic;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public interface ILanguageDictionary : IDisposable
+  {
+    string Language { get; }
+    IDictionaryEngine Engine { get; }
+    bool Check(string word);
+    List<string> Suggests(string word);
+  }
+}

ReSpeller/SpellEngine/Dictionaries/IUserInternalDictionary.cs

+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public interface IUserInternalDictionary : ILanguageDictionary
+  {
+    void AddToUserDict(string word);
+    void AddToInternalDict(string word);
+  }
+}

ReSpeller/SpellEngine/Dictionaries/UserInternalDictionary.cs

+using System.Collections.Generic;
+using System.IO;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  
+  public class UserInternalDictionary : IUserInternalDictionary
+  {
+    private readonly IDictionaryEngine myEngine;
+    private readonly string myLanguage;
+    private readonly IDictionaryStorage myUserStorage;
+    private readonly IDictionaryStorage myInternalStorage;
+
+
+    public UserInternalDictionary(IDictionaryEngine engine, string language, IDictionaryStorage userStorage, IDictionaryStorage internalStorage)
+    {
+      myEngine = engine;
+      myLanguage = language;
+      myUserStorage = userStorage;
+      myInternalStorage = internalStorage;
+      myEngine.AddRange(myUserStorage.GetContent());    
+      myEngine.AddRange(myInternalStorage.GetContent());
+    }
+
+    public void Dispose()
+    {
+      myEngine.Dispose();
+    }
+
+    public string Language { get { return myLanguage; } }
+
+    public IDictionaryEngine Engine { get { return myEngine; } }
+
+    public bool Check(string word)
+    {
+      return myEngine.Check(word);
+    }
+
+    public List<string> Suggests(string word)
+    {
+      return myEngine.Suggest(word);
+    }
+
+    public void AddToUserDict(string word)
+    {
+      myUserStorage.AddWord(word);
+      myEngine.Add(word);
+    }
+
+    public void AddToInternalDict(string word)
+    {
+      myInternalStorage.AddWord(word);
+      myEngine.Add(word);
+    }
+  }
+}

ReSpeller/SpellEngine/ISpellChecker.cs

     List<string> Suggestions(string word);
     void AddWordToUserDict(string word);
     void AddWordToCustomDict(string word);
+    void UpdateConfig();
   }
 }

ReSpeller/SpellEngine/IWordSuggestor.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ReSpeller.SpellEngine
+{
+  public interface IWordSuggestor
+  {
+    List<string> Suggest(string word);
+  }
+}

ReSpeller/SpellEngine/SingleDictionarySuggestor.cs

+using System.Collections.Generic;
+using System.Linq;
+using ReSpeller.SpellEngine.Dictionaries;
+
+namespace ReSpeller.SpellEngine
+{
+    public class SingleDictionarySuggestor : IWordSuggestor
+    {
+        private readonly ILanguageDictionary myDictionary;
+
+        public SingleDictionarySuggestor(ILanguageDictionary dictionary)
+        {
+            myDictionary = dictionary;
+        }
+
+        public List<string> Suggest(string word)
+        {
+            List<string> result = myDictionary.Suggests(word)
+                .Where(s => s.ToLower() != word.ToLower()) // filter suggests not equals original word
+                .Select(s => NamingStyleConverter.Convert(s, word)).ToList(); // convert style
+            return result.Any() ? result.ToList() : new List<string> { word };
+        }
+    }
+}

ReSpeller/SpellEngine/SpellChecker.cs

 using System.Reflection;
 using JetBrains.Application;
 using JetBrains.Application.Settings;
-using NHunspell;
 using ReSpeller.Settings;
+using ReSpeller.SpellEngine.Dictionaries;
 
 namespace ReSpeller.SpellEngine
 {
   public sealed class SpellChecker : IDisposable, ISpellChecker
   {
     private readonly IContextBoundSettingsStore myStore;
-    private const string CustomDictionaryPath = "dic/custom.dic";
-    private const int MaxLengthForSplit = 30;
-    private readonly List<string> myCustomDictionary = new List<string>();
-    private readonly Hunspell myHunspell;
-    private readonly string myPluginPath;
-    private readonly string myUserDicFilename;
-    private readonly HashSet<string> myUserDictionary = new HashSet<string>();
-    private volatile object myHunspellSync = new object();
-    //private readonly ReSpellerSettings mySettings;
+    private const string CurrentLanguage = "en_us";
+
+    private readonly UserInternalDictionary myDictionary;
+    private readonly string myPluginPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof (ISpellChecker)).Location);
+    private volatile object mySync = new object();
+    private readonly ConfigurableWordChecker myWordChecker;
+    private readonly IWordSuggestor myWordSuggestor;
 
     public SpellChecker(ISettingsStore store)
     {
-      
       myStore = store.BindToContextTransient(ContextRange.ApplicationWide);      
-      myPluginPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof (SpellChecker)).Location) +
-                     Path.DirectorySeparatorChar;
-      Hunspell.NativeDllPath = myPluginPath;
-      myHunspell = new Hunspell(myPluginPath + "dic/en_us.aff", myPluginPath + "dic/en_us.dic");
-
-      try
-      {
-        myCustomDictionary.AddRange(File.ReadAllLines(myPluginPath + CustomDictionaryPath));
-        myCustomDictionary.ForEach(s => myHunspell.Add(s));
-      }
-      catch
-      {
-      }
-      string userDicDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
-                                             "ResharperSpellChecker");
-      if (!Directory.Exists(userDicDirectory))
-      {
-        Directory.CreateDirectory(userDicDirectory);
-      }
-      myUserDicFilename = Path.Combine(userDicDirectory, "user.dic");
-      try
-      {
-        string[] readAllLines = File.ReadAllLines(myUserDicFilename);
-        foreach (var line in readAllLines)
-        {
-          myUserDictionary.Add(line);
-          myHunspell.Add(line);
-        }
-      }
-      catch
-      {
-      }
+      HunspellEngine.NativeDllPath = myPluginPath;
+      string mainDictDir = Path.Combine(myPluginPath, Constants.MainDictSubDir);
+      string userDictDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), Constants.UserDictSubDir);
+      var userStorage = new FileDictionaryStorage(Path.Combine(userDictDir, CurrentLanguage + "." + Constants.DictExt));
+      var internalStorage = new FileDictionaryStorage(Path.Combine(mainDictDir, CurrentLanguage + Constants.InternalDictSuffix + "." + Constants.DictExt));
+      HunspellEngine hunspellEngine = HunspellEngine.CreateForLanguage(mainDictDir, CurrentLanguage);
+      myDictionary = new UserInternalDictionary(hunspellEngine, CurrentLanguage, userStorage, internalStorage);
+      myWordChecker = new ConfigurableWordChecker(new List<ILanguageDictionary> {myDictionary});
+      myWordSuggestor = new SingleDictionarySuggestor(myDictionary);
     }
 
     #region IDisposable Members
 
     public void Dispose()
     {
-      myHunspell.Dispose();
+      myDictionary.Dispose();
     }
 
     #endregion
 
     public bool CheckWordSpelling(string word)
-    {
-      var settings = myStore.GetKey<ReSpellerSettings>(SettingsOptimization.DoMeSlowly);
-      if (word.Length < settings.MinWordLength)
-        return true;
-      lock (myHunspellSync)
+    {     
+      lock (mySync)
       {
-        // try to check in many styles
-        bool wholeWordCheck = myHunspell.Spell(word.ToLower()) 
-          || myHunspell.Spell(word.ToUpper())
-          || myHunspell.Spell(NamingStyleConverter.Convert(word, "Aaa"));
-        if (wholeWordCheck)
-          return true;
-        
-        //try to split into pair of words
-        if (settings.SplitInPairs)
-        {
-          if (word.Length < 4 || word.Length > MaxLengthForSplit) //min size of each word == 2, e.g. inplace -> in+place
-            //also very long words will be ignored
-            return false;
-          for (int i = 2; i < word.Length - 1; ++i)
-          {
-            string first = word.Substring(0, i);
-            string second = word.Substring(i);
-            if (myHunspell.Spell(first) && myHunspell.Spell(second))
-              return true;
-          }
-        }
-        return false;
+        return myWordChecker.Check(word);
       }
     }
 
     public List<string> Suggestions(string word)
     {
-      lock (myHunspellSync)
+      lock (mySync)
       {
-        List<string> result = myHunspell.Suggest(word)
-          .Where(s => s.ToLower() != word.ToLower()) // filter suggests not equals original word
-          .Select(s => NamingStyleConverter.Convert(s, word)).ToList(); // convert style
-        return result.Any() ? result.ToList() : new List<string> {word};
+        return myWordSuggestor.Suggest(word);
       }
     }
 
     public void AddWordToUserDict(string word)
     {
-      lock (myHunspellSync)
+      lock (mySync)
       {
-        string downcased = word.ToLower();
-        myUserDictionary.Add(downcased);
-        myHunspell.Add(downcased);
-        SaveUserDictionary();
+        myDictionary.AddToUserDict(word);
       }
     }
 
     public void AddWordToCustomDict(string word)
     {
-      lock (myHunspellSync)
+      lock (mySync)
       {
-        string downcased = word.ToLower();
-        string[] content = File.ReadAllLines(CustomDictionaryPath);
-        HashSet<string> hashSet = new HashSet<string>(content);
-        hashSet.Add(downcased);
-        File.WriteAllLines(CustomDictionaryPath, hashSet.ToArray());
-        myHunspell.Add(downcased);
+        myDictionary.AddToInternalDict(word);
       }
     }
 
-    private void SaveUserDictionary()
+    public void UpdateConfig()
     {
-      File.WriteAllLines(myUserDicFilename, myUserDictionary.ToArray());
+      var settings = myStore.GetKey<ReSpellerSettings>(SettingsOptimization.DoMeSlowly);
+      myWordChecker.Config.MinWordLength = settings.MinWordLength;
+      myWordChecker.Config.SplitInPairs = settings.SplitInPairs;
     }
   }
 }

ReSpeller/SpellEngine/SpellCheckerConfig.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ReSpeller.SpellEngine
+{
+  public class SpellCheckerConfig
+  {
+    public bool SplitInPairs { get; set; }
+    public int MinWordLength { get; set; }
+  }
+}

ReSpeller/Util.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ReSpeller
+{
+  public static class Util
+  {
+    public static string F(this string s, params object[] args)
+    {
+      return string.Format(s, args);
+    }
+  }
+}

dic/custom.dic

-accessor
-aggregator
-ajax
-alloc
-anyschema
-appender
-archivelog
-args
-arial
-arity
-asensitive
-attr
-auth
-authid
-autoboxing
-autocommit
-autoextend
-autoincrement
-autorelease
-autorotate
-backend
-backtrace
-barcode
-basedir
-basicfile
-bfile
-bigfile
-bigint
-binlog
-blog
-blogger
-blogging
-bool
-breakpoint
-breakpoints
-btree
-builtin
-bzip
-calc
-callee
-cancelable
-cancellable
-capath
-captcha
-ccflags
-cdata
-changelist
-charset
-checkbox
-checkboxes
-checksum
-chmod
-classpath
-clazz
-clob
-cloneable
-closable
-closeable
-cmdline
-codebase
-codesign
-commandline
-config
-configs
-configurator
-configurators
-const
-contravariant
-controlfile
-covariant
-cron
-ctrl
-datafile
-datafiles
-datetime
-dealloc
-deallocate
-decompile
-decompiled
-decompiler
-decompilers
-decompiles
-decompiling
-dedent
-deduplicate
-deferrable
-deque
-dereference
-dereferences
-desc
-dirs
-distinctrow
-django
-dojo
-draggable
-dtrace
-dumpfile
-dylib
-elseif
-elsif
-enqueue
-enum
-enums
-evex
-exif
-expr
-facebook
-filename
-fileset
-filesets
-filesystem
-finalizer
-finalizers
-foreach
-formatter
-freelist
-freelists
-freepools
-frontend
-fulltext
-func
-gdata
-geocode
-geometrycollection
-getters
-giud
-globals
-google
-hardcoded
-hardlink
-hardlinks
-helvetica
-holdability
-hostname
-hprof
-href
-hsqldb
-html
-http
-https
-impl
-inbox
-indextype
-indices
-infile
-init
-initializer
-initrans
-inline
-innodb
-inout
-instantiable
-insteadof
-intellij
-iphone
-iphoneos
-isnull
-javabean
-javabeans
-javac
-javadoc
-javaee
-javascript
-javax
-jetbrains
-jndi
-jquery
-json
-keepduplicates
-keychain
-keychains
-kotlin
-labeler
-labelers
-ldap
-libxml
-lifecycle
-likec
-linestring
-linkplain
-lldb
-llvm
-localhost
-localtime
-localtimestamp
-locator
-logfile
-login
-logoff
-logon
-logout
-longblob
-longtext
-lookup
-lucene
-lvalue
-lvalues
-macrodef
-maxdatafiles
-maxextents
-maximizable
-maxinstances
-maxlogfiles
-maxloghistory
-maxlogmembers
-maxsize
-maxtrans
-maxvalue
-mediumblob
-mediumint
-mediumtext
-metadata
-middleint
-millis
-minextents
-minimizable
-minvalue
-miny
-mlslabel
-mixin
-multi
-multilinestring
-multipoint
-multipolygon
-multiset
-mutex
-mutexes
-mysql
-namespace
-namespaces
-nchar
-nclob
-ndbcluster
-noarchivelog
-noaudit
-nocache
-nocompress
-nocopy
-nocreate
-nocycle
-nodegroup
-noinspection
-noinspections
-nohistory
-nologging
-nomapping
-nomaxvalue
-nominvalue
-nomonitoring
-nonatomic
-noninfingement
-nonschema
-noorder
-noparallel
-norely
-noresetlogs
-noreverse
-norowdependencies
-nosort
-notnull
-novalidate
-nowait
-nowrap
-nullabilities
-nullability
-nullif
-nvarchar
-oauth
-objc
-oidindex
-online
-onchange
-onclick
-openid
-openssl
-outfile
-overrider
-overriders
-param
-params
-patcher
-patchers
-pctfree
-pctincrease
-pctthreshold
-pctused
-pctversion
-permalink
-petersburg
-pipelined
-plaintext
-playlist
-plist
-plsql
-plugin
-plugins
-pointcut
-pointcuts
-polyadic
-popup
-popups
-posix
-postfix
-postgres
-postprocessing
-postprocessor
-pragma
-prebuilt
-prefetch
-prepend
-prepended
-prepends
-preprocessor
-processlist
-profiler
-progressbar
-proven
-pycharm
-readme
-readonly
-readwrite
-rect
-redistributions
-refactor
-refactored
-refactoring
-refactorings
-regex
-regexp
-reifiable
-reification
-reifications
-reified
-reifies
-reify
-reifying
-reindex
-renderer
-repo
-resetlogs
-resize
-rethrow
-rethrowing
-rethrown
-rethrows
-rlike
-rollup
-rowdependencies
-rtree
-rubymine
-runtime
-rvalue
-rvalues
-savepoint
-schemas
-scriptlet
-scriptlets
-securefile
-serializable
-serializer
-servererror
-servlet
-shader
-significand
-significands
-smallfile
-smallint
-soname
-sourcecode
-sourceforge
-spellchecker
-spellchecking
-sqlcode
-sqlerror
-sqlexception
-sqlstate
-sqlwarning
-startup
-stateful
-stdarg
-stdlib
-stmt
-strictfp
-stylesheet
-stylesheets
-sublicense
-subpackage
-subpartition
-subpartitions
-subst
-substring
-subtree
-subtrees
-subview
-subviews
-superclass
-superclasses
-superview
-superviews
-symlink
-symlinks
-sysdate
-systimestamp
-tablespace
-taglib
-temptable
-throwable
-timestamp
-tinyblob
-tinyint
-tinytext
-todo
-toggleable
-tokenize
-tokenizer
-tooltip
-tooltips
-trebuchet
-twitter
-typedef
-typedefs
-unboxing
-uncomment
-uncommented
-underwave
-undoable
-undofile
-unhandled
-uninstall
-unpivot
-unprotect
-unwatch
-uploader
-urowid
-username
-utf
-util
-utils
-uuid
-validator
-validators
-vararg
-varargs
-varbinary
-varchar
-varcharacter
-varray
-verdana
-versa
-vertices
-watchlist
-webservice
-whitespace
-whitespaces
-wifi
-wiki
-wildcard
-wildcards
-wordwrap
-workflow
-wsdl
-xcode
-xcodeproj
-xhtml
-xmlschema
-xmlschemas
-xmltype
-xpath
-xslt
-youtube
-zend
-zerofill
-xsd
-xml
-resx
-resmimetype
-www
-winfx
-xaml
-wpf
-cref
-typeparamref
-iis
-mvc
-sql
-mdf
-localizable
-asm
-aspnetdb
-csproj
-fwlink
-axd
-docx
-odt
-rtf
-txt
-wpd
-wps
-csv
-pptx
-ppt
-wav
-avi
-mov
-flv
-swf
-bmp
-gif
-jpg
-png
-psd
-svg
-pdf
-xls
-xlsx
-dbf
-mdb
-pdb
-cgi
-exe
-aspx
-cer
-css
-htm
-js
-jsp
-php
-rss
-ttf
-sys
-lnk
-cfg
-ini
-rar
-gz
-cpp
-dtd
-py
-sln
-vcxproj
-vbproj
-bak
-tmp
-msi
-clr

dic/en_US_custom.dic

+accessor
+aggregator
+ajax
+alloc
+anyschema
+appender
+archivelog
+args
+arial
+arity
+asensitive
+attr
+auth
+authid
+autoboxing
+autocommit
+autoextend
+autoincrement
+autorelease
+autorotate
+backend
+backtrace
+barcode
+basedir
+basicfile
+bfile
+bigfile
+bigint
+binlog
+blog
+blogger
+blogging
+bool
+breakpoint
+breakpoints
+btree
+builtin
+bzip
+calc
+callee
+cancelable
+cancellable
+capath
+captcha
+ccflags
+cdata
+changelist
+charset
+checkbox
+checkboxes
+checksum
+chmod
+classpath
+clazz
+clob
+cloneable
+closable
+closeable
+cmdline
+codebase
+codesign
+commandline
+config