clausewitz-spelling 0.1.17 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8fe17c11c32b6260c764e55e2bd4d508e37bdc2f
-  data.tar.gz: 61083f1bc484d2a8b8dbf960b5226b947e17a520
+  metadata.gz: 45dfa3f0e350c7b4b3ba9d1a6f69c970cb884134
+  data.tar.gz: c4ffb8579ab8787115d447b11fa49cb4a3159569
 SHA512:
-  metadata.gz: 42e7327da7a213edae016e730acb1177415453e3d87aa9771dda061b36f7fdfd01fe05966c8a35ef1fb4a650097025ad8de2c7c5f9ac6917361059d21ac02d62
-  data.tar.gz: a7199d624932691fdf0827c34bd7bf1cda2ff112817f27026cec2efc1bb03b5973cb8eb5ca2728f4e11f233f5ab02601db6426a9a768c9b2c2e2cc60c6463f8d
+  metadata.gz: 4661cea315ffec778213bf3b67ea6322973d19ce5a6302a23b2f8afef4eb1231583df251b7b098274bfd7b32b9d3f40cf01bca6cc65efd87bc3bd8581cd73e69
+  data.tar.gz: 44c9608f76e094a80d7ffd4924641ab65ede46b46a10a99daad2b70a4f7c9d0934df1f6b243a84deb23a71a9e21b2734e6205012f42d8c173e5cda9883bc6f97

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    clausewitz-spelling (0.1.17)
+    clausewitz-spelling (0.1.18)
       colorize
       damerau-levenshtein
       ffi-aspell

data/exe/clausewitz-spellcheck

@@ -15,6 +15,11 @@ class Main
       opt :suggestion_count,
         "How many suggestions to display",
         type: :int
+      Clausewitz::Localisation::LANG_MAP.each do |_, config|
+        opt "#{config.name}_dialect".to_sym,
+          "Select dialect for #{config.name.capitalize}",
+          type: :string
+      end
     end
     [opts, args]
   end

data/lib/clausewitz/localisation.rb

@@ -2,25 +2,58 @@ require 'yaml'
 
 module Clausewitz
   module Localisation
+    class LangConfig
+      attr_reader :name, :base, :dialects, :default_dialect
+      def initialize(name, base, dialects, default_dialect = nil)
+        @name             = name
+        @base             = base
+        @dialects         = dialects
+        @default_dialect  = default_dialect
+        @selected_dialect = @default_dialect
+      end
+
+      def clausewitz_name
+        "l_#{@name}"
+      end
+
+      def select_dialect(dialect)
+        if @dialects.include?(dialect)
+          @selected_dialect = dialect
+        else
+          fail("Unknown dialect override '#{dialect}'!")
+        end
+      end
+
+      def full_name
+        @selected_dialect ? "#{@base}_#{@selected_dialect.upcase}" : @base
+      end
+    end
+
     LANG_MAP = {
-      'english' => {
-        base: 'en'
-      },
-      'french' => {
-        base: 'fr'
-      },
-      'german' => {
-        base: 'de'
-      },
-      'portuguese' => {
-        base: 'pt'
-      },
-      'russian' => {
-        base: 'ru'
-      },
-      'spanish' => {
-        base: 'es'
-      }
+      'l_english' => LangConfig.new(
+        'english',
+        'en', %w[gb us ca], 'gb'
+      ),
+      'l_french' => LangConfig.new(
+        'french',
+        'fr', %w[fr ca], 'fr'
+      ),
+      'l_german' => LangConfig.new(
+        'german',
+        'de', %w[de], 'de'
+      ),
+      'l_portuguese' => LangConfig.new(
+        'portuguese',
+        'pt', %w[pt br], 'pt'
+      ),
+      'l_spanish' => LangConfig.new(
+        'spanish',
+        'es', []
+      ),
+      'l_russian' => LangConfig.new(
+        'russian',
+        'ru', []
+      )
     }
 
     def self.parse(text)
@@ -56,7 +89,7 @@ module Clausewitz
       end
     end
 
-    VALID_LANG_REGEX = /^l_(#{LANG_MAP.keys.join('|')})/
+    VALID_LANG_REGEX = /(#{LANG_MAP.keys.join('|')})/
     def self.valid_lang?(lang)
       lang =~ VALID_LANG_REGEX
     end

data/lib/clausewitz/spelling/checker.rb

@@ -20,6 +20,16 @@ module Clausewitz; module Spelling
         @dictionary_root = Pathname.new(@dictionary_root)
       end
 
+      dialect_opts = opts.keys.select { |k| k =~ /.+_dialect/ }
+      dialect_opts.each do |dialect_opt_key|
+        next unless opts[dialect_opt_key]
+        next if dialect_opt_key.to_s.end_with?('given')
+        language_name = dialect_opt_key[/(.+)_dialect/, 1]
+        config = language_config(language_name)
+        dialect = opts[dialect_opt_key]
+        config.select_dialect(dialect.downcase)
+      end
+
       @loaded_spellcheckers = {}
       @loaded_wordlists     = {}
     end
@@ -41,22 +51,25 @@ module Clausewitz; module Spelling
         return UnparseableFileResult.new(filepath, e)
       end
 
-      checks = contents.map do |lang, entries|
-        check_entries(lang, entries)
+      checks = contents.map do |lang_name, entries|
+        lc = language_config(lang_name)
+        check_entries(lc, entries)
       end
       FileResults.new(filepath, checks)
     end
 
     private
 
-    def check_entries(lang, entries)
-      wordlist = load_wordlist(lang)
-      aspell_checker = load_aspell_checker(lang)
+    def check_entries(lc, entries)
+      wordlist = load_wordlist(lc)
+      aspell_checker = load_aspell_checker(lc)
       spellcheck_ignore = entries&.delete('spellcheck_ignore')
       ignored_keys = spellcheck_ignore ? spellcheck_ignore.split(',') : []
       ignored_keys << 'spellcheck_ignore'
-      return IgnoredLangResult.new(lang) if ignored_keys.include?('all')
-      return LangResults.new(lang, []) unless entries
+      if ignored_keys.include?('all')
+        return IgnoredLangResult.new(lc.clausewitz_name)
+      end
+      return LangResults.new(lc.clausewitz_name, []) unless entries
       checks = entries.map do |key, entry|
         if ignored_keys.include?(key)
           IgnoredEntryResult.new(key)
@@ -64,7 +77,7 @@ module Clausewitz; module Spelling
           check_entry(aspell_checker, wordlist, key, entry)
         end
       end
-      LangResults.new(lang, checks)
+      LangResults.new(lc.clausewitz_name, checks)
     end
 
     def check_entry(checker, wordlist, key, entry)
@@ -73,6 +86,7 @@ module Clausewitz; module Spelling
       # TODO: Look into supporting escaped square brackets as part of the
       #       string.
       entry.gsub!(/\[.+\]/, '')
+      entry.gsub!(/\$([A-Z]|\||\d|=)+\$/, '')
 
       # Remove other localisation bits we don't care about.
       entry.gsub!(/§(%|\*|=|\d|W|G|R|B|Y|b|M|g|T|l|H|\+|-|!)/, '')
@@ -120,7 +134,8 @@ module Clausewitz; module Spelling
       return if is_ordinal?(word)
       return if is_percentage?(word)
       return if is_icon?(word)
-      return if is_define?(word)
+      return if is_initial?(word)
+      return if is_psalm?(word)
       return if wordlist.include?(word)
 
       if !checker.correct?(word)
@@ -128,6 +143,14 @@ module Clausewitz; module Spelling
       end
     end
 
+    def is_psalm?(word)
+      word =~ /^\d+:\d+$/
+    end
+
+    def is_initial?(word)
+      word =~ /^[A-Z]\.$/
+    end
+
     def suggest_words(checker, wordlist, word)
       return [] if word.size < 3
 
@@ -151,10 +174,6 @@ module Clausewitz; module Spelling
       word =~ /^£\w+/
     end
 
-    def is_define?(word)
-      word =~ /^\$(\w|\|)+\$/
-    end
-
     def is_number?(word)
       Float(word) != nil rescue false
     end
@@ -171,15 +190,16 @@ module Clausewitz; module Spelling
     # Loads our custom wordlist into a temporary Aspell dictionary.
     # This way Aspell won't yell at us for custom words and will also
     # potentially select from this list as suggestions for misspelled words.
-    def load_custom_dictionary(lang)
-      dir = Dir.mktmpdir("custom-wordlist-#{lang}-")
-      output = File.join(dir, "#{lang}-custom.wlst")
+    def load_custom_dictionary(lc)
+      dir = Dir.mktmpdir("custom-wordlist-#{lc.full_name}-")
+      output = File.join(dir, "#{lc.full_name}-custom.wlst")
       cmd = %W[
-        aspell --lang=#{lang} --encoding=UTF-8 create master #{output}
+        aspell --lang=#{lc.base} --encoding=UTF-8 create master #{output}
       ]
       value = nil
       Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
-				contents = File.read(File.join(@dictionary_root, lang, 'dict.txt'))
+        dict_path = File.join(@dictionary_root, lc.full_name, 'dict.txt')
+				contents = File.read(dict_path)
 				words = contents.lines.map(&:chomp)
         words.each do |word|
           stdin.puts(word)
@@ -188,36 +208,44 @@ module Clausewitz; module Spelling
         value = wait_thr.value
       end
 			unless value.success?
-      	fail("Could not generate custom word list for #{lang}!")
+      	fail("Could not generate custom word list for #{lc.full_name}!")
 			end
       output
     end
 
-    def load_aspell_checker(lang)
-      return @loaded_spellcheckers[lang] if @loaded_spellcheckers[lang]
-      aspell_lang_config = Localisation::LANG_MAP.select do |config_key, _|
-        lang.sub(/^l_/, '') == config_key
-      end.first
-      lang_code = aspell_lang_config.last[:base]
-      aspell_checker = FFI::Aspell::Speller.new(lang_code, encoding: 'UTF-8')
+    def load_aspell_checker(lc)
+      if @loaded_spellcheckers[lc.full_name]
+        return @loaded_spellcheckers[lc.full_name]
+      end
+      aspell_checker = FFI::Aspell::Speller.new(
+        lc.full_name, encoding: 'UTF-8'
+      )
 			aspell_checker.set('ignore-accents', true)
-      if @dictionary_root && @dictionary_root.join(lang_code).exist?
-        custom_words = load_custom_dictionary(lang_code)
+      if @dictionary_root && @dictionary_root.join(lc.full_name).exist?
+        custom_words = load_custom_dictionary(lc)
 				aspell_checker.set('extra-dicts', custom_words)
       end
-			@loaded_spellcheckers[lang] = aspell_checker
+			@loaded_spellcheckers[lc.full_name] = aspell_checker
+    end
+
+    def load_wordlist(lc)
+      return @loaded_wordlists[lc.full_name] if @loaded_wordlists[lc.full_name]
+      contents = ''
+      dict_path = @dictionary_root.join(lc.full_name, 'dict.txt')
+      if @dictionary_root && dict_path.exist?
+				contents = File.read(@dictionary_root.join(lc.full_name, 'dict.txt'))
+      end
+      words = contents.lines.to_a.map(&:chomp)
+			@loaded_wordlists[lc.full_name] = Set.new(words)
     end
 
-    def load_wordlist(lang)
-      return @loaded_wordlists[lang] if @loaded_wordlists[lang]
-      aspell_lang_config = Localisation::LANG_MAP.select do |config_key, _|
-        lang.sub(/^l_/, '') == config_key
-      end.first
-      lang_code = aspell_lang_config.last[:base]
-      if @dictionary_root && @dictionary_root.join(lang_code).exist?
-				contents = File.read(@dictionary_root.join(lang_code, 'dict.txt'))
+    def language_config(language_name)
+      language_name = "l_#{language_name}" if language_name !~ /^l_/
+      aspell_lang_config = Localisation::LANG_MAP.find do |config_key, _|
+        language_name == config_key
       end
-			@loaded_wordlists[lang] = Set.new(contents.lines.to_a.map(&:chomp))
+      fail("Unknown language '#{language_name}'!") unless aspell_lang_config
+      aspell_lang_config.last
     end
 
     # Make sure a file to be checked is actually present and readable.

data/lib/clausewitz/spelling/version.rb

@@ -1,5 +1,5 @@
 module Clausewitz
   module Spelling
-    VERSION = "0.1.17"
+    VERSION = "0.1.18"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: clausewitz-spelling
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.18
 platform: ruby
 authors:
 - Will Chappell