clausewitz-spelling 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4014a78444b4229f57cc23e9bc8d02fbdb31acae
-  data.tar.gz: b7fe59713b71f23c3ffed9d297c1af91a8d667b3
+  metadata.gz: 928fb347a0cf9627f9d5fe15bf41cdcde863bfc6
+  data.tar.gz: c953a1f747632c9068f953fb49d6f849cff88c9b
 SHA512:
-  metadata.gz: 6f9f4a9c0cf05519b35122469c938a1a2bc99a059222c19007d86afc59a7bbdf9bcc9bcea510a9295df0c73886a45859e68cea4b19fcdb52cfcfd58b2c7dc843
-  data.tar.gz: e247e1f39f9867fd518525860e67975e172474f0a23a754fa4412e66c35c42c504452650dc8dbb2bf2ea331e1e89d45e3077e9030a5282e8ffb9a1426b2c42ab
+  metadata.gz: 7d3a8fac9a0f8600406a7d6a074eeee3620da864ed4f5bfc2c8e7b59431f88232959cb45858e6fa78cf27a7347a6d6b0c7753ba63da63a9e55d66a967ee70922
+  data.tar.gz: 564fc2d7c4b478b96bb18157fc27bbf67919d8d849bee0bad349376a28f911cb09f76f0014a2c969543a24156130198edd2964c76c7d3b72c57ad0e9a61324bf

data/Gemfile.lock

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

data/bin/console

@@ -2,6 +2,7 @@
 
 require "bundler/setup"
 require "clausewitz/spelling"
+require "clausewitz/localisation"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/exe/clausewitz-spellcheck

@@ -9,14 +9,8 @@ class Main
 
   def parse_args(args)
     opts = Optimist::options(args) do
-      opt :custom_wordlist,
-        "Text file containing newline-delimited list of custom words",
-        type: :string
-      opt :english_dialect,
-        "Two-letter code indicating dialect of English to use",
-        type: :string
-      opt :spanish_dialect,
-        "Two-letter code indicating dialect of Spanish to use",
+      opt :dictionary_root,
+        "Directory containing per-language custom word lists",
         type: :string
       opt :suggestion_count,
         "How many suggestions to display",
@@ -27,9 +21,9 @@ class Main
 
   def run
     spellchecker = Clausewitz::Spelling::Checker.new(@opts)
-    results = spellchecker.check_files(@args)
-    results.render
-    !results.failed?
+    results = @args.map { |arg| spellchecker.check_file(arg) }
+    results.each { |r| puts r }
+    !results.any?(&:failed?)
   end
 end
 

data/lib/clausewitz/localisation.rb

@@ -0,0 +1,64 @@
+require 'yaml'
+
+module Clausewitz
+  module Localisation
+    LANG_MAP = {
+      'english' => {
+        base: 'en'
+      },
+      'french' => {
+        base: 'fr'
+      },
+      'german' => {
+        base: 'de'
+      },
+      'portuguese' => {
+        base: 'pt'
+      },
+      'russian' => {
+        base: 'ru'
+      },
+      'spanish' => {
+        base: 'es'
+      }
+    }
+
+    def self.parse(text)
+      smudged_text = text.lines.map do |line|
+        self.smudge_key(line)
+      end
+      contents = YAML.load(smudged_text.join("\n"))
+      self.validate_localisation!(contents)
+      contents.each do |lang, entries|
+        entry_keys = entries ? entries.keys : []
+        entry_keys.each do |key|
+          entries[unsmudge_key(key)] = entries.delete(key)
+        end
+      end
+      contents
+    end
+
+    def self.parse_file(filepath)
+      self.parse(File.read(filepath))
+    end
+
+    def self.smudge_key(line)
+      line.sub(/\:([0-9]+) /, '!!!\1: ')
+    end
+
+    def self.validate_localisation!(contents)
+      fail("Unknown language keys!") unless contents.keys.all? do |lang|
+        self.valid_lang?(lang)
+      end
+    end
+
+    VALID_LANG_REGEX = /^l_(#{LANG_MAP.keys.join('|')})/
+    def self.valid_lang?(lang)
+      lang =~ VALID_LANG_REGEX
+    end
+
+    def self.unsmudge_key(line)
+      line.sub(/!!!([0-9]+)$/, ':\1')
+    end
+  end
+end

data/lib/clausewitz/spelling.rb

@@ -2,6 +2,5 @@ require "clausewitz/spelling/version"
 
 module Clausewitz
   module Spelling
-    # Your code goes here...
   end
 end

data/lib/clausewitz/spelling/checker.rb

@@ -1,140 +1,149 @@
 require 'ffi/aspell'
 require 'open3'
+require 'pathname'
 require 'set'
 require 'tmpdir'
 require 'yaml'
 require 'damerau-levenshtein'
+require 'clausewitz/localisation'
 require 'clausewitz/spelling/results'
 
 module Clausewitz; module Spelling
   class Checker
     attr_accessor :dict_words
     def initialize(opts = {})
-
+      @dictionary_root  = opts[:dictionary_root]
       @suggestion_count = opts[:suggestion_count] || 3
 
-      @english_dialect = opts[:english_dialect] || 'GB'
-      @english_dialect = "en_#{@english_dialect}"
-      @en_speller = FFI::Aspell::Speller.new(
-        @english_dialect,
-        encoding: 'UTF-8'
-      )
-
-      @spanish_dialect = opts[:spanish_dialect] || 'es'
-      @spanish_dialect = "es_#{@spanish_dialect}" if opts[:spanish_dialect]
-      @es_speller = FFI::Aspell::Speller.new(
-        @spanish_dialect,
-        encoding: 'UTF-8'
-      )
-
-      dict_path = opts[:custom_wordlist]
-
-      if dict_path
-        fail("No such file #{dict_path}!") unless File.exist?(dict_path)
-        @dict_words = Set.new(File.read(dict_path).lines.map(&:chomp).to_a)
-        @custom_words_filepath = generate_word_list
-        @en_speller.set('extra-dicts', @custom_words_filepath)
-        @en_speller.set('ignore-accents', true)
-      else
-        @dict_words = Set.new([])
-        @en_speller.set('ignore-accents', true)
+      if @dictionary_root
+        @dictionary_root = Pathname.new(@dictionary_root)
       end
+
+      @loaded_spellcheckers = {}
+      @loaded_wordlists     = {}
     end
 
-    def check_file(file_path)
-      $stderr.puts "Checking #{file_path}..."
-      loc = load_file(file_path)
-      # Poorly formatted YAML files often lack proper indentation; you can
-      # easily discover this by checking to make sure all top level keys are
-      # actual language names.
-      bad_keys = loc.keys.select { |key| bad_lang_key(key) }
-      bad_keys.map! { |key| unsmudge_key(key) }
-      if !bad_keys.empty?
-        UnknownLangsFileResult.new(file_path, bad_keys)
-      else
-        results = loc.map do |lang, entries|
-          check_entries(lang, entries)
-        end
-        FileResults.new(file_path, results)
+    def check_file(filepath)
+      results = []
+      begin
+        filepath = Pathname.new(filepath)
+        validate_filepath!(filepath)
+      rescue => e
+        return InvalidFilepathResult.new(filepath, e)
       end
-    rescue Psych::SyntaxError => e
-      # If we fail to load the file it's probably busted.
-      BadFormatFileResult.new(file_path, e)
-    end
 
-    def check_files(file_paths)
-      results = Array(file_paths).map do |file_path|
-        check_file(file_path) unless File.directory?(file_path)
+      $stderr.puts "Skipping #{filepath}..." if filepath.directory?
+
+      begin
+        contents = Clausewitz::Localisation.parse_file(filepath)
+      rescue => e
+        return UnparseableFileResult.new(filepath, e)
       end
-      OverallResults.new(results.compact)
-    end
 
-    def check_entries(lang, entries)
-      misspellings = []
-      if entries && !entries.empty?
-        entries.each do |key, text|
-          result = check_entry(key, text)
-          misspellings << result unless result.check_results.empty?
-        end
+      checks = contents.map do |lang, entries|
+        check_entries(lang, entries)
       end
-      LangResults.new(lang, misspellings)
+      FileResults.new(filepath, checks)
     end
 
-    def check_entry(key, text)
-      misspellings = []
-      text = preprocess_entry(text)
-      text.split(/(\s|—)/).each_with_index do |word, index|
-        unless check_word(word) || misspellings.any? { |ms| ms.misspelled_word == word }
-          misspellings << CheckResult.new(word, suggest_words(word))
+    private
+
+    def check_entries(lang, entries)
+      wordlist = load_wordlist(lang)
+      aspell_checker = load_aspell_checker(lang)
+      spellcheck_ignore = entries&.delete('spellcheck_ignore')
+      ignored_keys = spellcheck_ignore ? spellcheck_ignore.split(',') : []
+      return IgnoredLangResult.new(lang) if ignored_keys.include?('all')
+      return LangResults.new(lang, []) unless entries
+      checks = entries.map do |key, entry|
+        if ignored_keys.include?(key)
+          IgnoredEntryResult.new(key)
+        else
+          check_entry(aspell_checker, wordlist, key, entry)
         end
       end
-      KeyResults.new(unsmudge_key(key), misspellings)
-    end
+      LangResults.new(lang, checks)
+    end
+
+    def check_entry(checker, wordlist, key, entry)
+      # We don't want to pay attention to scripted localisation, so we'll strip
+      # it out before we start.
+      # TODO: Look into supporting escaped square brackets as part of the
+      #       string.
+      entry.gsub!(/\[.+\]/, '')
+
+      # Remove other localisation bits we don't care about.
+      entry.gsub!(/§(%|\*|=|\d|W|G|R|B|Y|b|M|g|T|l|H|\+|-|!)/, '')
+
+      # We should also remove punctuation that is never part of words, like
+      # exclamation points, commas, semi-colons, and question marks.
+      # We should be using proper apostrophes for possessives in our loc.
+      entry.gsub!(/(!|;|\?|'|"|“|”|:|\$|\(|\))/, '')
+
+      # If a word has one full stop at the end with no other full stops
+      # elsewhere in the word, it's probably an acronym or initialism like
+      # U.S.A. and so we should avoid stripping it. Otherwise, it's probably
+      # the end of a sentence and can be ignored.
+      words = entry.split(/\s|—/)
+      words.map! do |word|
+        if word.end_with?('...')
+          word.sub(/\.\.\.$/, '')
+        elsif word =~ /\.$/ && word.chars.count('.') == 1
+          word.sub(/\.$/, '')
+        elsif word =~ /,$/
+          word.sub(/,$/, '')
+        else
+          word
+        end
+      end.join(" ")
 
-    SQUIGGLE = '§'
-    def check_word(word)
-      return true if word.chars.count('.') > 1
-      word.gsub!(/^(#{SQUIGGLE}.|[[:punct:]])+/, '')
-      word.gsub!(/(#{SQUIGGLE}.|[[:punct:]])+$/, '')
-      not_word?(word) ||
-        @dict_words.include?(word) ||
-        @en_speller.correct?(word) ||
-        @es_speller.correct?(word)
+      checks = words.map { |word| check_word(checker, wordlist, word) }.compact
+      EntryResults.new(key, checks)
     end
 
-    def load_file(file_path)
-      contents = nil
-      File.open(file_path, 'r:UTF-8') do |f|
-        contents = f.read
+    def check_word(checker, wordlist, word)
+      return if is_number?(word)
+      return if is_ordinal?(word)
+      return if is_percentage?(word)
+      return if is_icon?(word)
+      return if wordlist.include?(word)
+
+      if !checker.correct?(word)
+        MisspelledWordResult.new(word, suggest_words(checker, wordlist, word))
       end
-      contents = contents.lines.map do |line|
-        smudge_key(line)
-      end.join("\n")
-      YAML.load(contents)
     end
 
-    def not_word?(word)
-      is_percentage?(word) ||
-        is_number?(word) ||
-        is_ordinal?(word) ||
-        word =~ /^£/
-    end
+    def suggest_words(checker, wordlist, word)
+      return [] if word.size < 3
 
-    private
+      suggestions = Set.new
+
+      aspell_suggestions = checker.suggestions(word)
+
+      custom_suggestions = wordlist.select do |dict_word|
+        DamerauLevenshtein.distance(word, dict_word) < word.size
+      end
+
+      aspell_suggestions.each { |sug| suggestions.add(sug) }
+      custom_suggestions.each { |sug| suggestions.add(sug) }
 
-    def bad_lang_key(key)
-      key !~ /^l_.+/
+      suggestions.to_a.sort_by do |sug|
+        DamerauLevenshtein.distance(sug, word)
+      end.first(@suggestion_count)
     end
 
-    def is_ordinal?(word)
-      word =~ /[0-9]+(th|st|nd|rd)/
+    def is_icon?(word)
+      word =~ /^£\w+/
     end
 
     def is_number?(word)
       Float(word) != nil rescue false
     end
 
-    # Tries to detect if a word is a percentage and can be skipped.
+    def is_ordinal?(word)
+      word =~ /[0-9]+(th|st|nd|rd)/
+    end
+
     def is_percentage?(word)
       word =~ /(-|\+)?[0-9]+(\.[0-9]+)?%/ ||
         word =~ /%(-|\+)?[0-9]+(\.[0-9]+)?/
@@ -143,55 +152,59 @@ 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 generate_word_list
-      dir = Dir.mktmpdir('custom-wordlist-')
-      output = File.join(dir, 'fallout_words.wlst')
+    def load_custom_dictionary(lang)
+      dir = Dir.mktmpdir("custom-wordlist-#{lang}-")
+      output = File.join(dir, "#{lang}-custom.wlst")
       cmd = %W[
         aspell --lang=en --encoding=UTF-8 create master #{output}
       ]
       value = nil
       Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
-        @dict_words.each do |word|
+				contents = File.read(File.join(@dictionary_root, lang, 'dict.txt'))
+				words = contents.lines.map(&:chomp)
+        words.each do |word|
           stdin.puts(word)
         end
         stdin.close
         value = wait_thr.value
       end
-      fail("Could not generate custom word list!") unless value.success?
+			unless value.success?
+      	fail("Could not generate custom word list for #{lang}!")
+			end
       output
     end
 
-    def preprocess_entry(entry)
-      entry.gsub(/\[.+\]/, '')
-    end
-
-    def smudge_key(key)
-      key.sub(/\:([0-9]+) /, "!!!1: ")
+    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')
+			aspell_checker.set('ignore-accents', true)
+      if @dictionary_root && @dictionary_root.join(lang_code).exist?
+        custom_words = load_custom_dictionary(lang_code)
+				aspell_checker.set('extra-dicts', custom_words)
+      end
+			@loaded_spellcheckers[lang] = aspell_checker
     end
 
-    def suggest_words(word)
-      return [] if word.size < 5
-
-      suggestions = Set.new
-
-      aspell_suggestions = []
-      aspell_suggestions.concat(@en_speller.suggestions(word))
-      aspell_suggestions.concat(@es_speller.suggestions(word))
-
-      custom_suggestions = @dict_words.select do |dict_word|
-        DamerauLevenshtein.distance(word, dict_word) < word.size
+    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'))
       end
-
-      aspell_suggestions.each { |sug| suggestions.add(sug) }
-      custom_suggestions.each { |sug| suggestions.add(sug) }
-
-      suggestions.to_a.sort_by do |sug|
-        DamerauLevenshtein.distance(sug, word)
-      end.first(@suggestion_count)
+			@loaded_wordlists[lang] = Set.new(contents.lines.to_a.map(&:chomp))
     end
 
-    def unsmudge_key(key)
-      key.gsub(/!!!([0-9]+)$/, ":1")
+    # Make sure a file to be checked is actually present and readable.
+    def validate_filepath!(filepath)
+      fail("No such file #{filepath}!") unless filepath.exist?
+      fail("Cannot read #{filepath}!")  unless filepath.readable?
     end
   end
-end; end # Clausewitz::Spelling
+end; end

data/lib/clausewitz/spelling/results.rb

@@ -1,137 +1,174 @@
 require 'colorize'
 
 module Clausewitz; module Spelling
-  # Stores the results of a run over a set of files.
-  class OverallResults
-    attr_reader :file_results
-    def initialize(file_results)
-      @file_results = file_results
+  class FileResults
+    def initialize(filepath, lang_results)
+      @filepath     = filepath
+      @lang_results = lang_results
     end
 
     def failed?
-      @file_results.any?(&:failed?)
+      @lang_results.any?(&:failed?)
     end
 
-    def render
-      @file_results.each(&:render)
+    def to_s
+      outfile = failed? ? @filepath.to_s.red : "#{@filepath} passed".green
+      failures = @lang_results.select(&:failed?)
+      "#{outfile}\n" + failures.map { |l| "  #{l}" }.join("\n")
     end
   end
 
-  class FileResults
-    attr_reader :file_path, :lang_results
-    def initialize(file_path, lang_results)
-      @file_path    = file_path
-      @lang_results = lang_results
+  class LangResults
+    def initialize(lang, entry_results)
+      @lang          = lang
+      @entry_results = entry_results
     end
 
     def failed?
-      @lang_results.any?(&:failed?)
+      @entry_results.any?(&:failed?)
     end
 
-    def render
-      successful, failed = @lang_results.partition do |lang|
-        lang.key_results.empty?
-      end
-      successful.each do |lang|
-        puts "  #{@file_path.yellow}:#{lang.lang.yellow} #{'passed'.green}"
-      end
-      failed.each do |lang|
-        failed_count = lang.key_results.size.to_s.red
-        puts "  #{@file_path.yellow}:#{lang.lang.yellow} has #{failed_count} keys with errors:"
-        lang.key_results.each(&:render)
-      end
+    def to_s
+      to_str
+    end
+
+    def to_str(indent = 0)
+      firstspacer = ' ' * indent
+      spacer = ' ' * (indent + 2)
+      failures = @entry_results.select(&:failed?)
+      outlines = failures.map { |e| "#{spacer}#{e.to_str(indent + 2)}" }
+      outlines = outlines.join("\n")
+      outlang = failed? ? @lang.red : @lang.green
+      out = "#{firstspacer}#{outlang}\n#{outlines}"
     end
   end
 
-  class BadFormatFileResult
-    attr_reader :file_path, :error
-    def initialize(file_path, error)
-      @file_path = file_path
-      @error = error
+  class IgnoredLangResult
+    def initialize(lang)
+      @lang = lang
     end
 
     def failed?
-      true
+      false
     end
 
-    def render
-      puts "  #{@file_path.yellow} #{'appears to be formatted incorrectly:'.red}"
-      puts "  #{@error.message.red}"
+    def to_s
+      to_str
+    end
+
+    def to_str(indent = 0)
+      firstspacer = ' ' * indent
+      "#{firstspacer}#{@lang} ignored".yellow
     end
   end
 
-  class UnknownLangsFileResult
-    attr_reader :file_path, :bad_langs
-    def initialize(file_path, bad_langs)
-      @file_path = file_path
-      @bad_langs = bad_langs
+  class EntryResults
+    def initialize(key, word_results)
+      @key          = key
+      @word_results = word_results
     end
 
     def failed?
-      true
+      !@word_results.empty?
     end
 
-    def render
-      puts "  #{@file_path.yellow} #{'has unknown language keys!'.red}"
-      puts "    Make sure that each loc key has *two* leading *spaces*.".yellow
+    def to_s
+      to_str
+    end
+
+    def to_str(indent = 0)
+      spacer = ' ' * indent
+      if failed?
+        outlines = @word_results.map { |w| "#{spacer}#{w.to_str(indent + 2)}" }
+        outlines = outlines.join("\n")
+        "#{spacer}#{@key.red}\n#{outlines}"
+      else
+        "#{spacer}#{@key} passed".green
+      end
     end
   end
 
-  class LangResults
-    attr_reader :lang, :key_results
-    def initialize(lang, key_results)
-      @lang        = lang
-      @key_results = key_results
+  class IgnoredEntryResult
+    def initialize(key)
+      @key = key
     end
 
     def failed?
-      !@key_results.empty?
+      false
     end
 
-    def render
-      puts "    #{@lang} has #{@key_results.size.to_s.red} keys with errors:"
-      @key_results.each(&:render)
+    def to_s
+      to_str
+    end
+
+    def to_str(indent = 0)
+      firstspacer = ' ' * indent
+      "#{firstspacer}#{@key} ignored".yellow
     end
   end
 
-  class KeyResults
-    attr_reader :key, :check_results
-    def initialize(key, check_results)
-      @key           = key
-      @check_results = check_results
+  class MisspelledWordResult
+    def initialize(word, suggestions)
+      @word        = word
+      @suggestions = suggestions
     end
 
     def failed?
-      !@check_results.empty?
+      true
+    end
+
+    def to_s
+      to_str
+    end
+
+    def to_str(indent = 0)
+      spacer = ' ' * indent
+      msg = "#{spacer}#{@word}".red
+
+      if @suggestions && !@suggestions.empty?
+        msg += " (#{@suggestions.join(', ')})".yellow
+      else
+        msg += " (-- no suggestions --)".yellow
+      end
+
+      msg
     end
+  end
 
-    def render
-      puts "      #{@key.yellow} has #{@check_results.size.to_s.red} unrecognized words:"
-      @check_results.each(&:render)
+  # Result capturing basic problems interacting with the file before parsing.
+  class InvalidFilepathResult
+    attr_reader :filepath, :error
+    def initialize(filepath, error)
+      @filepath = filepath
+      @error    = error
+    end
+
+    def failed?
+      true
     end
   end
 
-  class CheckResult
-    attr_reader :misspelled_word, :suggestions
-    def initialize(misspelled_word, suggestions)
-      @misspelled_word = misspelled_word
-      @suggestions     = suggestions
+  # Result capturing problems parsing a readable file.
+  class UnparseableFileResult
+    attr_reader :filepath, :error
+    def initialize(filepath, error)
+      @filepath = filepath
+      @error    = error
     end
 
     def failed?
       true
     end
 
-    def render
-      print "        Unrecognized word '#{@misspelled_word.red}'"
-      if @suggestions.empty?
-        puts
-      else
-        puts "; did you mean:"
-        @suggestions.each do |sug|
-          puts "                          '#{sug.green}'"
-        end
-      end
+    def to_s
+      to_str
+    end
+
+    def to_str(indent = 0)
+      spacer = ' ' * indent
+      secondspacer = ' ' * (indent + 2)
+      "#{spacer}#{@filepath} could not be parsed\n".red +
+        "#{secondspacer}#{@error.message}".red
     end
   end
 end; end # Clausewitz::Spelling

data/lib/clausewitz/spelling/version.rb

@@ -1,5 +1,5 @@
 module Clausewitz
   module Spelling
-    VERSION = "0.1.9"
+    VERSION = "0.1.10"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clausewitz-spelling
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Will Chappell
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-13 00:00:00.000000000 Z
+date: 2019-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -144,9 +144,9 @@ files:
 - bin/setup
 - clausewitz-spelling.gemspec
 - exe/clausewitz-spellcheck
+- lib/clausewitz/localisation.rb
 - lib/clausewitz/spelling.rb
 - lib/clausewitz/spelling/checker.rb
-- lib/clausewitz/spelling/formatter.rb
 - lib/clausewitz/spelling/results.rb
 - lib/clausewitz/spelling/version.rb
 homepage: http://github.com/wtchappell/clausewitz-spelling

data/lib/clausewitz/spelling/formatter.rb

@@ -1,36 +0,0 @@
-module Clausewitz; module Spelling
-  class Formatter
-    def render(overall_results)
-      render_overall_results(overall_results)
-    end
-
-    private
-
-    def render_overall_results(overall_results)
-      overall_results.files.each do |file_results|
-        render_file_results(file_results)
-      end
-    end
-
-    def render_file_results(file_results)
-      file_results.langs.each do |lang_results|
-        render_lang_results(lang_results)
-      end
-    end
-
-    def render_lang_results(lang_results)
-      lang_results.keys.each do |key_results|
-        render_key_results(key_results)
-      end
-    end
-
-    def render_key_results(key_results)
-      key_results.spellchecks.each do |spellcheck_result|
-        render_spellcheck_result(spellcheck_result)
-      end
-    end
-
-    def render_spellcheck_result(spellcheck_result)
-    end
-  end
-end; end # Clausewitz::Spelling