Commits

Nerzhul500 committed 49dfbbc

New Spell engine seems working

  • Participants
  • Parent commits 2e6d400
  • Branches spellengine_refactoring

Comments (0)

Files changed (18)

File ReSpeller/ReSpeller.csproj

     <Compile Include="Settings\ReSpellerSettingsControl.xaml.cs">
       <DependentUpon>ReSpellerSettingsControl.xaml</DependentUpon>
     </Compile>
-    <Compile Include="SpellEngine\DictionaryFactory.cs" />
-    <Compile Include="SpellEngine\CustomizableDictionary.cs" />
-    <Compile Include="SpellEngine\HunspellDictionary.cs" />
-    <Compile Include="SpellEngine\IDictionary.cs" />
-    <Compile Include="SpellEngine\ICustomizableDictionary.cs" />
+    <Compile Include="SpellEngine\Dictionaries\DictionaryFactory.cs" />
+    <Compile Include="SpellEngine\Dictionaries\FileDictionaryStorage.cs" />
+    <Compile Include="SpellEngine\Dictionaries\HunspellEngine.cs" />
+    <Compile Include="SpellEngine\Dictionaries\HunspellLanguageDictionary.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\NamingStyleConverter.cs" />
     <Compile Include="SpellEngine\RangeUtils.cs" />
     <Compile Include="SpellEngine\SpellChecker.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" />
     <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>
+    </None>
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>

File ReSpeller/SpellEngine/CustomizableDictionary.cs

-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-
-namespace ReSpeller.SpellEngine
-{
-  public class CustomizableDictionary : ICustomizableDictionary
-  {
-    private readonly IDictionary myBaseDict;
-    private readonly string myUserDictFilename;
-
-    public CustomizableDictionary(IDictionary baseDict, string language, string userDictDir)
-    {
-      myBaseDict = baseDict;
-      myUserDictFilename = Path.Combine(userDictDir, language + ".dic");
-      if (!File.Exists(myUserDictFilename))
-      {
-        throw new FileNotFoundException("User dictionary for language {0} not found: {1}".F(language, myUserDictFilename));
-      }
-    }
-
-    public CustomizableDictionary(string userDictFilename) 
-    {
-      if (File.Exists(userDictFilename))
-      {
-        throw new FileNotFoundException("User dictionary not found: {0}".F(userDictFilename));
-      }
-      myUserDictFilename = userDictFilename;
-    }
-
-    private void LoadWordsFromFile(string userDictFile)
-    {
-      List<string> words = File.ReadAllLines(userDictFile).ToList();
-      words.ForEach(s => myBaseDict.AddToEngine(s));
-    }
-
-    public void AddUserWord(string word)
-    {
-      string[] words = File.ReadAllLines(myUserDictFilename);
-      HashSet<string> content = new HashSet<string>(words);
-      content.Add(word);
-      File.WriteAllLines(myUserDictFilename, content.ToArray());
-    }
-
-    public void Dispose()
-    {     
-      myBaseDict.Dispose();
-    }
-
-    public string Language { get { return myBaseDict.Language; } }
-
-    public bool Check(string word)
-    {
-      return myBaseDict.Check(word);
-    }
-
-    public List<string> Suggests(string word)
-    {
-      return myBaseDict.Suggests(word);
-    }
-
-    public void AddToEngine(string word)
-    {
-      myBaseDict.AddToEngine(word);
-    }
-  }
-}

File 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();
+    }
+  }
+}

File 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))
+        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();
+    }
+  }
+}

File ReSpeller/SpellEngine/Dictionaries/HunspellEngine.cs

+using System.Collections.Generic;
+using NHunspell;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public class HunspellEngine : IDictionaryEngine
+  {
+    private readonly Hunspell myHunspell;
+
+    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();
+    }
+  }
+}

File ReSpeller/SpellEngine/Dictionaries/HunspellLanguageDictionary.cs

+using System.Collections.Generic;
+using System.IO;
+using Microsoft.Deployment.Compression;
+using NHunspell;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public class HunspellLanguageDictionary : ILanguageDictionary
+  {
+    private readonly string myLanguage;
+    private readonly IDictionaryEngine myEngine;
+    private const string HunspellAffixExt = "aff";
+    private const string HunspellDicExt = "dic";
+
+    public static string NativeDllPath
+    {
+      get { return Hunspell.NativeDllPath; }
+      set { Hunspell.NativeDllPath = value; }
+    }
+
+    public HunspellLanguageDictionary(string mainDictDir, string language)
+    {
+      if (string.IsNullOrEmpty(language))
+        throw new ArchiveException(language);
+      myLanguage = language;
+      string affixFile = Path.Combine(mainDictDir, language + "." + HunspellAffixExt);
+      string dictFile = Path.Combine(mainDictDir, language + "." + HunspellDicExt);
+      myEngine = new HunspellEngine(affixFile, dictFile);
+    }
+
+    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 Dispose()
+    {
+      myEngine.Dispose();
+    }
+  }
+}

File 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);
+  }
+}

File ReSpeller/SpellEngine/Dictionaries/IDictionaryStorage.cs

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

File 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);
+  }
+}

File ReSpeller/SpellEngine/Dictionaries/IUserInternalDictionary.cs

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

File ReSpeller/SpellEngine/Dictionaries/UserInternalDictionary.cs

+using System.Collections.Generic;
+using System.IO;
+
+namespace ReSpeller.SpellEngine.Dictionaries
+{
+  public class UserInternalDictionary : IUserInternalDictionary
+  {
+    private const string DictExt = "dic";
+    private const string InternalDictSuffix = "_custom";
+    private readonly ILanguageDictionary myLanguageDictionary;
+    private readonly IDictionaryStorage myUserStorage;
+    private readonly IDictionaryStorage myInternalStorage;
+
+
+    public UserInternalDictionary(ILanguageDictionary languageDictionary, string userDictDir, string internalDictDir)
+    {
+      myLanguageDictionary = languageDictionary;
+      myUserStorage = new FileDictionaryStorage(Path.Combine(userDictDir, languageDictionary.Language + "." + DictExt));
+      myLanguageDictionary.Engine.AddRange(myUserStorage.GetContent());
+      myInternalStorage = new FileDictionaryStorage(Path.Combine(internalDictDir, 
+                                                                 languageDictionary.Language + InternalDictSuffix + "." + DictExt));
+      myLanguageDictionary.Engine.AddRange(myInternalStorage.GetContent());
+    }
+
+    public void Dispose()
+    {
+      myLanguageDictionary.Dispose();
+    }
+
+    public string Language { get { return myLanguageDictionary.Language; } }
+
+    public IDictionaryEngine Engine { get { return myLanguageDictionary.Engine; } }
+
+    public bool Check(string word)
+    {
+      return myLanguageDictionary.Check(word);
+    }
+
+    public List<string> Suggests(string word)
+    {
+      return myLanguageDictionary.Suggests(word);
+    }
+
+    public void AddToUserDict(string word)
+    {
+      myUserStorage.AddWord(word);
+      myLanguageDictionary.Engine.Add(word);
+    }
+
+    public void AddToInternalDict(string word)
+    {
+      myInternalStorage.AddWord(word);
+      myLanguageDictionary.Engine.Add(word);
+    }
+  }
+}

File ReSpeller/SpellEngine/DictionaryFactory.cs

-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace ReSpeller.SpellEngine
-{
-  public interface IDictionaryFactory
-  {
-    IDictionary CreateDictionary(string language);
-    ICustomizableDictionary CreateCustomizableDictionary(IDictionary baseDict, string language);
-    ICustomizableDictionary CreateCustomizableDictionary(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 IDictionary CreateDictionary(string language)
-    {
-      throw new NotImplementedException();
-    }
-
-    public ICustomizableDictionary CreateCustomizableDictionary(IDictionary baseDict, string language)
-    {
-      throw new NotImplementedException();
-    }
-
-    public ICustomizableDictionary CreateCustomizableDictionary(string language)
-    {
-      throw new NotImplementedException();
-    }
-  }
-}

File ReSpeller/SpellEngine/HunspellDictionary.cs

-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using NHunspell;
-
-namespace ReSpeller.SpellEngine
-{
-  public class HunspellDictionary : IDictionary
-  {
-    private readonly string myLanguage;
-    public const string HunspellAffixExt = "aff";
-    public const string HunspellDicExt = "dic";
-
-    private readonly Hunspell myHunspell;
-    private readonly string myAdditionalDicPath;
-
-    public static string NativeDllPath
-    {
-      get { return Hunspell.NativeDllPath; }
-      set { Hunspell.NativeDllPath = value; }
-    }
-
-    public HunspellDictionary(string mainDictDir, string language)
-    {
-      myLanguage = language;
-      string affixFile = Path.Combine(mainDictDir, language + "." + HunspellAffixExt);
-      if (!File.Exists(affixFile))
-        throw new FileNotFoundException("Affix file for language {0} not found: {1}".F(language, affixFile));
-      string dictFile = Path.Combine(mainDictDir, language + "." + HunspellDicExt);
-      if (!File.Exists(dictFile))
-        throw new FileNotFoundException("Dictionary file for language {0} not found: {1}".F(language, dictFile));
-      myHunspell = new Hunspell(affixFile, dictFile);
-    }
-
-    public HunspellDictionary(string mainDictDir, string language, string additionalDictFilename) : this(mainDictDir, language)
-    {
-      myAdditionalDicPath = Path.Combine(mainDictDir, additionalDictFilename);
-      if (!File.Exists(myAdditionalDicPath))
-      {
-        myHunspell.Dispose();
-        throw new FileNotFoundException("Additional dictionary for languge {0} not found: {1}".F(language, myAdditionalDicPath));
-      }
-      List<string> additionalDict = File.ReadAllLines(myAdditionalDicPath).ToList();
-      additionalDict.ForEach(s => myHunspell.Add(s));
-    }
-
-    protected Hunspell Hunspell
-    {
-      get { return myHunspell; }
-    }
-
-    public string Language
-    {
-      get { return myLanguage; }
-    }
-
-    public bool Check(string word)
-    {
-      return myHunspell.Spell(word);
-    }
-
-    public List<string> Suggests(string word)
-    {
-      return myHunspell.Suggest(word);
-    }
-
-    public void AddToEngine(string word)
-    {
-      myHunspell.Add(word);
-    }
-
-    public void AddAdditionalWord(string word)
-    {
-      string downcased = word.ToLower();
-      string[] content = File.ReadAllLines(myAdditionalDicPath);
-      HashSet<string> hashSet = new HashSet<string>(content);
-      hashSet.Add(downcased);
-      File.WriteAllLines(myAdditionalDicPath, hashSet.ToArray());
-      myHunspell.Add(downcased);
-    }
-
-    public void Dispose()
-    {
-      if (myHunspell != null && !myHunspell.IsDisposed)
-        myHunspell.Dispose();
-    }
-  }
-}

File ReSpeller/SpellEngine/ICustomizableDictionary.cs

-namespace ReSpeller.SpellEngine
-{
-  public interface ICustomizableDictionary : IDictionary
-  {
-    void AddUserWord(string word);
-  }
-}

File ReSpeller/SpellEngine/IDictionary.cs

-using System;
-using System.Collections.Generic;
-
-namespace ReSpeller.SpellEngine
-{
-  public interface IDictionary : IDisposable
-  {
-    string Language { get; }
-    bool Check(string word);
-    List<string> Suggests(string word);
-    void AddToEngine(string word);
-  }
-}

File 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 string MainDictSubDir = "dic";
+    private const string UserDictSubDir = "ReSpeller";
+    private const string CurrentLanguage = "en_us";
+
+    private readonly UserInternalDictionary myDictionary;
     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 readonly string myPluginPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof (SpellChecker)).Location);
+    private volatile object mySync = new object();
 
     public SpellChecker(ISettingsStore store)
     {
-      
       myStore = store.BindToContextTransient(ContextRange.ApplicationWide);      
-      myPluginPath = Path.GetDirectoryName(Assembly.GetAssembly(typeof (SpellChecker)).Location) +
-                     Path.DirectorySeparatorChar;
-      HunspellDictionary.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
-      {
-      }
+      HunspellLanguageDictionary.NativeDllPath = myPluginPath;
+      string mainDictDir = Path.Combine(myPluginPath, MainDictSubDir);
+      string userDictDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), UserDictSubDir);
+      var dictionary = new HunspellLanguageDictionary(mainDictDir, CurrentLanguage);
+      myDictionary = new UserInternalDictionary(dictionary, userDictDir, mainDictDir);
     }
 
     #region IDisposable Members
 
     public void Dispose()
     {
-      myHunspell.Dispose();
+      myDictionary.Dispose();
     }
 
     #endregion
       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"));
+        bool wholeWordCheck = myDictionary.Check(word.ToLower())
+          || myDictionary.Check(word.ToUpper())
+          || myDictionary.Check(NamingStyleConverter.Convert(word, "Aaa"));
         if (wholeWordCheck)
           return true;
         
           {
             string first = word.Substring(0, i);
             string second = word.Substring(i);
-            if (myHunspell.Spell(first) && myHunspell.Spell(second))
+            if (myDictionary.Check(first) && myDictionary.Check(second))
               return true;
           }
         }
 
     public List<string> Suggestions(string word)
     {
-      lock (myHunspellSync)
+      lock (mySync)
       {
-        List<string> result = myHunspell.Suggest(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};
 
     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()
-    {
-      File.WriteAllLines(myUserDicFilename, myUserDictionary.ToArray());
-    }
   }
 }

File 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

File 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
+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