spellr 0.9.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60659d04d7461c60fc7880fe44fa4af1d6b852511affaef3722d8bca7902bebe
-  data.tar.gz: 6327cb52ae02517918e886b774311f09270dc1e96166361962c49f9f01f28506
+  metadata.gz: 21ab4e433d233e14066dd74202d26ce302ea6b61807b06c74d5418f0351f576a
+  data.tar.gz: 865fe94e51e2ad6b819eef675b2075eaaf15214bc599e14de2c76b376169ad3a
 SHA512:
-  metadata.gz: 1aadb5c07c9ce3fa8899be299810480034d1bfed1e93aa9fe0e07192edb9cac21e8c505908da7757badb0190da5d0251c47cf135306aa60cde8abbee2a4e3db8
-  data.tar.gz: 7fc321f6665f93c4093a46748781eb59ce56930c334298670e5592d63887e97092bc2ab49394ab08f143d8a84a213e4df76a149b6f97065b51f78feebc56e91c
+  metadata.gz: ff244a207751f57b402c1c5080487205935a4c80fd0b2481cd8a58a12ba717412596714c1684fde3e28aac6caff182e8985855243dc02c720463d17e1e533bc8
+  data.tar.gz: bf87a587fd6cf7ab5ef907645cfc68b627f65098b9e771c09a9fb19360467817c05cb3d61bda17bb01296f81a71e23048f42ec4054e1cd8a96703332571f1ff1

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# v0.10.1
+- Resolve fast_ignore follow_symlinks deprecation
+
+# v0.10.0
+- Drop ruby 2.4 support, to allow for...
+- Spelling suggestions while using `spellr --interactive`
+- And a new, probably frequently wrong, `spellr --autocorrect`
+
+# v0.9.1
+- Assume all files are utf8, more comprehensively. (Sets ::Encoding.default_external and default_internal while running)
+
 # v0.9.0
 - Recognize url with _ in query string and zero length path
 - Assume all files are utf8

data/README.md

@@ -27,7 +27,7 @@ However, in a programming context spelling things _consistently_ is useful, wher
 
 ## Installation
 
-This is tested against ruby 2.4-3.0.
+This is tested against ruby 2.5-3.0.
 
 ### With Bundler
 
@@ -66,6 +66,7 @@ $ spellr # will run the spell checker
 $ spellr --interactive # will run the spell checker, interactively
 $ spellr --wordlist # will output all words that fail the spell checker in spellr wordlist format
 $ spellr --quiet # will suppress all output
+$ spellr --autocorrect # for if you're feeling lucky
 ```
 
 To check a single file or subset of files, just add paths or globs:
@@ -123,14 +124,16 @@ To start an interactive spell checking session:
 $ spellr --interactive
 ```
 
-You'll be shown each word that's not found in a dictionary, it's location (path:line:column), along with a prompt.
+You'll be shown each word that's not found in a dictionary, it's location (path:line:column), along with suggestions, and a prompt.
 ```
 file.rb:1:0 notaword
+Did you mean: [1] notwork, [2] nonword
 [a]dd, [r]eplace, [s]kip, [h]elp, [^C] to exit: [ ]
 ```
 
 Type `h` for this list of what each letter command does
 ```
+[1]...[2] Replace notaword with the numbered suggestion
 [a] Add notaword to a word list
 [r] Replace notaword
 [R] Replace this and all future instances of notaword
@@ -144,9 +147,20 @@ What do you want to do? [ ]
 
 ---
 
+If you type a numeral the word will be replaced with that numbered suggestion
+```
+file.txt:1:0 notaword
+Did you mean: [1] notwork, [2] nonword
+[a]dd, [r]eplace, [s]kip, [h]elp, [^C] to exit: [2]
+Replaced notaword with nonword
+```
+
+---
+
 If you type `r` or `R` you'll be shown a prompt with the original word and it prefilled ready for correcting:
 ```
 file.txt:1:0 notaword
+Did you mean: [1] notwork, [2] nonword
 [a]dd, [r]eplace, [s]kip, [h]elp, [^C] to exit: [r]
 
   [^C] to go back
@@ -167,6 +181,7 @@ Lowercase `s` will skip this particular use of the word, uppercase `S` will also
 If you instead type `a` you'll be shown a list of possible wordlists to add to. This list is based on the file path, and is configurable in `.spellr.yml`.
 ```
 file.txt:1:0 notaword
+Did you mean: [1] notwork, [2] nonword
 [a]dd, [r]eplace, [s]kip, [h]elp, [^C] to exit: [a]
 
   [e] english
@@ -247,7 +262,7 @@ languages:
       - path/to/logstash/file
 ```
 
-## Rake and Travis
+## Rake
 
 Create or open a file in the root of your project named `Rakefile`.
 adding the following lines
@@ -260,7 +275,27 @@ Spellr::RakeTask.generate_task
 This will add the `rake spellr` task. To provide arguments like the cli, use square brackets. (ensure you escape the `[]` if you're using zsh)
 `rake 'spellr[--interactive]'`
 
-To have this automatically run on travis, add `:spellr` to the default task.
+To provide default cli arguments, the first argument is the name, and subsequent arguments are the cli arguments.
+```ruby
+# Rakefile
+require 'spellr/rake_task'
+Spellr::RakeTask.generate_task(:spellr_quiet, '--quiet')
+
+task default: :spellr_quiet
+```
+or `rake spellr` will be in interactive mode unless the CI env variable is set.
+```ruby
+# Rakefile
+require 'spellr/rake_task'
+spellr_arguments = ENV['CI'] ? [] : ['--interactive']
+Spellr::RakeTask.generate_task(:spellr, **spellr_arguments)
+
+task default: :spellr
+```
+
+## Travis
+
+To have this automatically run on travis, add `:spellr` to the default rake task.
 ```ruby
 # Rakefile
 require 'spellr/rake_task'
@@ -284,28 +319,10 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.5
+  - 3.0
 before_install: gem install bundler
 ```
 
-To provide default cli arguments, the first argument is the name, and subsequent arguments are the cli arguments.
-```ruby
-# Rakefile
-require 'spellr/rake_task'
-Spellr::RakeTask.generate_task(:spellr_quiet, '--quiet')
-
-task default: :spellr_quiet
-```
-or `rake spellr` will be in interactive mode unless the CI env variable is set.
-```ruby
-# Rakefile
-require 'spellr/rake_task'
-spellr_arguments = ENV['CI'] ? [] : ['--interactive']
-Spellr::RakeTask.generate_task(:spellr, **spellr_arguments)
-
-task default: :spellr
-```
-
 ## Ignoring the configured patterns
 
 Sometimes you'll want to spell check something that would usually be ignored,

data/exe/spellr

@@ -3,4 +3,7 @@
 
 require_relative '../lib/spellr/cli'
 
+::Encoding.default_external = ::Encoding::UTF_8
+::Encoding.default_internal = ::Encoding::UTF_8
+
 exit Spellr::CLI.new(ARGV).run

data/lib/spellr/autocorrect_reporter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../spellr'
+require_relative 'base_reporter'
+require_relative 'suggester'
+
+module Spellr
+  class AutocorrectReporter < BaseReporter
+    def finish
+      puts "\n"
+      print_count(:checked, 'file')
+      print_value(total, 'error', 'found')
+      print_count(:total_fixed, 'error', 'fixed', hide_zero: true)
+      print_count(:total_unfixed, 'error', 'unfixed', hide_zero: true)
+    end
+
+    def call(token)
+      super
+
+      handle_replace(token)
+    end
+
+    private
+
+    def total
+      counts[:total_unfixed] + counts[:total_fixed]
+    end
+
+    def handle_replace(token)
+      replacement = ::Spellr::Suggester.suggestions(token).first
+      return increment(:total_unfixed) unless replacement
+
+      token.replace(replacement)
+      increment(:total_fixed)
+      puts "Replaced #{red(token)} with #{green(replacement)}"
+      throw :check_file_from, token
+    end
+  end
+end

data/lib/spellr/backports.rb

@@ -1,50 +1,7 @@
 # frozen_string_literal: true
 
 module Spellr
-  ruby_version = Gem::Version.new(RUBY_VERSION)
-  unless ruby_version >= Gem::Version.new('2.5')
-    module HashSlice
-      refine Hash do
-        def slice!(*keys)
-          delete_if { |k| !keys.include?(k) }
-        end
-
-        def slice(*keys)
-          dup.slice!(*keys)
-        end
-      end
-    end
-
-    require 'yaml'
-    module YAMLSymbolizeNames
-      refine YAML.singleton_class do
-        alias_method :safe_load_without_symbolize_names, :safe_load
-        def safe_load(path, *args, symbolize_names: false, **kwargs)
-          if symbolize_names
-            symbolize_names!(safe_load_without_symbolize_names(path, *args, **kwargs))
-          else
-            safe_load_without_symbolize_names(path, *args, **kwargs)
-          end
-        end
-
-        private
-
-        def symbolize_names!(obj) # rubocop:disable Metrics/MethodLength
-          case obj
-          when Hash
-            obj.keys.each do |key| # rubocop:disable Style/HashEachMethods # each_key never finishes.
-              obj[key.to_sym] = symbolize_names!(obj.delete(key))
-            end
-          when Array
-            obj.map! { |ea| symbolize_names!(ea) }
-          end
-          obj
-        end
-      end
-    end
-  end
-
-  unless ruby_version >= Gem::Version.new('2.6')
+  unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
     require 'yaml'
     module YAMLPermittedClasses
       refine YAML.singleton_class do

data/lib/spellr/base_reporter.rb

@@ -46,5 +46,13 @@ module Spellr
     def counts
       output.counts
     end
+
+    def print_count(stat, noun, verb = stat, hide_zero: false)
+      print_value(counts[stat], noun, verb, hide_zero: hide_zero)
+    end
+
+    def print_value(value, noun, verb, hide_zero: false)
+      puts "#{pluralize noun, value} #{verb}" if !hide_zero || value.positive?
+    end
   end
 end

data/lib/spellr/check.rb

@@ -3,6 +3,7 @@
 require_relative '../spellr'
 require_relative 'tokenizer'
 require_relative 'string_format'
+require_relative 'output_stubbed'
 
 module Spellr
   class Check
@@ -21,8 +22,10 @@ module Spellr
     end
 
     def check
-      files.each do |file|
-        check_and_count_file(file)
+      if Spellr.config.parallel
+        parallel_check
+      else
+        files.each { |file| check_and_count_file(file, reporter) }
       end
 
       reporter.finish
@@ -30,24 +33,47 @@ module Spellr
 
     private
 
-    def check_and_count_file(file)
-      check_file(file)
-      reporter.output.increment(:checked)
-    rescue Spellr::InvalidByteSequence
-      # sometimes files are binary
-      reporter.warn "Skipped unreadable file: #{aqua file.relative_path}"
+    def parallel_check
+      require 'parallel'
+
+      Parallel.each(files, finish: ->(_, _, result) { reporter.output << result }) do |file|
+        sub_reporter = reporter.class.new(Spellr::OutputStubbed.new)
+        check_and_count_file(file, sub_reporter)
+        sub_reporter.output
+      end
     end
 
-    def check_file(file, start_at = nil, found_word_proc = wordlist_proc_for(file))
+    def check_and_count_file(file, current_reporter)
+      check_file(file, current_reporter)
+      current_reporter.output.increment(:checked)
+    rescue Spellr::InvalidByteSequence, ::Errno::ENOENT, ::Errno::EISDIR, ::Errno::EACCES
+      current_reporter.warn "Skipped unreadable file: #{aqua file.relative_path}"
+    end
+
+    def check_file(file, curr_reporter, start_at = nil, wordlist_proc = wordlist_proc_for(file))
+      restart_token = catch(:check_file_from) do
+        report_file(file, curr_reporter, start_at, wordlist_proc)
+        nil
+      end
+      check_file_from_restart(file, curr_reporter, restart_token, wordlist_proc) if restart_token
+    end
+
+    def report_file(file, curr_reporter, start_at = nil, wordlist_proc = wordlist_proc_for(file))
       Spellr::Tokenizer.new(file, start_at: start_at)
-        .each_token(skip_term_proc: found_word_proc) do |token|
-          reporter.call(token)
-          reporter.output.exit_code = 1
+        .each_token(skip_term_proc: wordlist_proc) do |token|
+          curr_reporter.call(token)
+          curr_reporter.output.exit_code = 1
         end
     end
 
+    def check_file_from_restart(file, current_reporter, restart_token, wordlist_proc)
+      # new wordlist cache when adding a word
+      wordlist_proc = wordlist_proc_for(file) unless restart_token.replacement
+      check_file(file, current_reporter, restart_token.location, wordlist_proc)
+    end
+
     def wordlist_proc_for(file)
-      wordlists = Spellr.config.wordlists_for(file).sort_by(&:length).reverse
+      wordlists = file.wordlists
 
       ->(term) { wordlists.any? { |w| w.include?(term) } }
     end

data/lib/spellr/cli_options.rb

@@ -9,8 +9,6 @@ module Spellr
     class Options
       class << self
         def parse(argv)
-          @parallel_option = false
-
           options.parse!(argv)
         end
 
@@ -25,6 +23,7 @@ module Spellr
           opts.on('-w', '--wordlist', 'Outputs errors in wordlist format', &method(:wordlist_option))
           opts.on('-q', '--quiet', 'Silences output', &method(:quiet_option))
           opts.on('-i', '--interactive', 'Runs the spell check interactively', &method(:interactive_option))
+          opts.on('-a', '--autocorrect', 'Autocorrect errors', &method(:autocorrect_option))
           opts.separator('')
           opts.on('--[no-]parallel', 'Run in parallel or not, default --parallel', &method(:parallel_option))
           opts.on('-d', '--dry-run', 'List files to be checked', &method(:dry_run_option))
@@ -54,9 +53,12 @@ module Spellr
 
         def interactive_option(_)
           require_relative 'interactive'
-          require_relative 'check_interactive'
           Spellr.config.reporter = Spellr::Interactive.new
-          Spellr.config.checker = Spellr::CheckInteractive unless @parallel_option
+        end
+
+        def autocorrect_option(_)
+          require_relative 'autocorrect_reporter'
+          Spellr.config.reporter = Spellr::AutocorrectReporter.new
         end
 
         def suppress_file_rules(_)
@@ -73,15 +75,8 @@ module Spellr
           Spellr.config.config_file = file
         end
 
-        def parallel_option(parallel) # rubocop:disable Metrics/MethodLength
-          @parallel_option = true
-          Spellr.config.checker = if parallel
-            require_relative 'check_parallel'
-            Spellr::CheckParallel
-          else
-            require_relative 'check'
-            Spellr::Check
-          end
+        def parallel_option(parallel)
+          Spellr.config.parallel = parallel
         end
 
         def dry_run_option(_)

data/lib/spellr/config.rb

@@ -10,7 +10,7 @@ require 'pathname'
 
 module Spellr
   class Config
-    attr_writer :reporter, :checker
+    attr_writer :reporter, :parallel
 
     attr_accessor :suppress_file_rules, :dry_run
 
@@ -68,6 +68,10 @@ module Spellr
       @reporter ||= default_reporter
     end
 
+    def parallel
+      defined?(@parallel) ? @parallel : default_parallel
+    end
+
     def checker
       return dry_run_checker if dry_run?
 
@@ -101,8 +105,12 @@ module Spellr
     end
 
     def default_checker
-      require_relative 'check_parallel'
-      Spellr::CheckParallel
+      require_relative 'check'
+      Spellr::Check
+    end
+
+    def default_parallel
+      reporter.class.name != 'Spellr::Interactive'
     end
   end
 end

data/lib/spellr/config_loader.rb

@@ -32,7 +32,7 @@ module Spellr
     def load_yaml(path)
       return {} unless ::File.exist?(path)
 
-      YAML.safe_load(::File.read(path, encoding: ::Encoding::UTF_8), symbolize_names: true)
+      YAML.safe_load(::File.read(path), symbolize_names: true)
     end
 
     def merge_config(default, project) # rubocop:disable Metrics/MethodLength

data/lib/spellr/config_validator.rb

@@ -8,7 +8,7 @@ module Spellr
   class ConfigValidator
     include Spellr::Validations
 
-    validate :checker_and_reporter_coexist
+    validate :not_interactive_and_parallel
     validate :interactive_is_interactive
     validate :only_has_one_key_per_language
     validate :languages_with_conflicting_keys
@@ -31,11 +31,11 @@ module Spellr
       nil
     end
 
-    def checker_and_reporter_coexist
-      if Spellr.config.reporter.class.name == 'Spellr::Interactive' &&
-          Spellr.config.checker.name == 'Spellr::CheckParallel'
-        errors << 'CLI error: --interactive is incompatible with --parallel'
-      end
+    def not_interactive_and_parallel
+      return unless Spellr.config.reporter.class.name == 'Spellr::Interactive' &&
+        Spellr.config.parallel
+
+      errors << 'CLI error: --interactive is incompatible with --parallel'
     end
 
     def only_has_one_key_per_language

data/lib/spellr/file.rb

@@ -34,7 +34,11 @@ module Spellr
     end
 
     def read_write
-      write(yield(read(encoding: ::Encoding::UTF_8)), encoding: ::Encoding::UTF_8)
+      write(yield read)
+    end
+
+    def wordlists
+      ::Spellr.config.wordlists_for(self).sort_by { |wordlist| -wordlist.length }
     end
   end
 end

data/lib/spellr/file_list.rb

@@ -35,11 +35,10 @@ module Spellr
       }
     end
 
-    def fast_ignore # rubocop:disable Metrics/MethodLength
+    def fast_ignore
       FastIgnore.new(
         **configured_rules,
         argv_rules: @patterns,
-        follow_symlinks: true,
         root: Spellr.pwd_s
       )
     end

data/lib/spellr/interactive.rb

@@ -5,18 +5,17 @@ require_relative '../spellr'
 require_relative 'interactive_add'
 require_relative 'interactive_replacement'
 require_relative 'base_reporter'
+require_relative 'suggester'
 
 module Spellr
   class Interactive < BaseReporter # rubocop:disable Metrics/ClassLength
-    def finish # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def finish
       puts "\n"
-      puts "#{pluralize 'file', counts[:checked]} checked"
-      puts "#{pluralize 'error', total} found"
-      if counts[:total_skipped].positive?
-        puts "#{pluralize 'error', counts[:total_skipped]} skipped"
-      end
-      puts "#{pluralize 'error', counts[:total_fixed]} fixed" if counts[:total_fixed].positive?
-      puts "#{pluralize 'word', counts[:total_added]} added" if counts[:total_added].positive?
+      print_count(:checked, 'file')
+      print_value(total, 'error', 'found')
+      print_count(:total_skipped, 'error', 'skipped', hide_zero: true)
+      print_count(:total_fixed, 'error', 'fixed', hide_zero: true)
+      print_count(:total_added, 'word', 'added', hide_zero: true)
     end
 
     def global_replacements
@@ -27,22 +26,25 @@ module Spellr
       @global_skips ||= counts[:global_skips] = []
     end
 
-    def call(token)
+    def call(token, only_prompt: false)
       # if attempt_global_replacement succeeds, then it throws,
       # it acts like a guard clause all by itself.
       attempt_global_replacement(token)
       return if attempt_global_skip(token)
 
-      super
+      super(token) unless only_prompt
+
+      suggestions = ::Spellr::Suggester.fast_suggestions(token)
+      print_suggestions(suggestions) unless only_prompt
 
-      prompt(token)
+      prompt(token, suggestions)
     end
 
     def prompt_for_key
       print "[ ]\e[2D"
     end
 
-    def loop_within(seconds) # rubocop:disable Metrics/MethodLength
+    def loop_within(seconds)
       # timeout is just because it gets stuck sometimes
       Timeout.timeout(seconds * 10) do
         start_time = monotonic_time
@@ -84,11 +86,21 @@ module Spellr
       "^#{char.tr(CTRL_STR, ALPHABET)}"
     end
 
-    def prompt(token)
+    def print_suggestions(suggestions)
+      return if suggestions.empty?
+
+      puts "Did you mean: #{number_suggestions(suggestions)}"
+    end
+
+    def number_suggestions(suggestions)
+      suggestions.map.with_index(1) { |word, i| "#{key i.to_s} #{word}" }.join(', ')
+    end
+
+    def prompt(token, suggestions)
       print "#{key 'add'}, #{key 'replace'}, #{key 'skip'}, #{key 'help'}, [^#{bold 'C'}] to exit: "
       prompt_for_key
 
-      handle_response(token)
+      handle_response(token, suggestions)
     end
 
     def clear_line(lines = 1)
@@ -121,9 +133,17 @@ module Spellr
       throw :check_file_from, token
     end
 
-    def handle_response(token) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def suggestions_options(suggestions)
+      return suggestions if suggestions.empty?
+
+      ('1'..(suggestions.length.to_s)).to_a
+    end
+
+    def handle_response(token, suggestions) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
+      numbers = suggestions_options(suggestions)
       # :nocov:
-      case stdin_getch("qaAsSrR?h\u0003\u0004")
+      letter = stdin_getch("qaAsSrR?h\u0003\u0004#{numbers.join}")
+      case letter
       # :nocov:
       when 'q', "\u0003" # ctrl c
         Spellr.exit 1
@@ -137,20 +157,37 @@ module Spellr
         Spellr::InteractiveReplacement.new(token, self).global_replace
       when 'r'
         Spellr::InteractiveReplacement.new(token, self).replace
+      when *numbers
+        handle_replace_with_suggestion(token, suggestions, letter)
       when '?', 'h'
-        handle_help(token)
+        handle_help(token, suggestions)
       end
     end
 
+    def handle_replace_with_suggestion(token, suggestions, letter)
+      replacement = suggestions[letter.to_i - 1].chomp
+
+      token.replace(replacement)
+      increment(:total_fixed)
+      puts "Replaced #{red(token)} with #{green(replacement)}"
+      throw :check_file_from, token
+    end
+
     def handle_skip(token)
       increment(:total_skipped)
       yield token if block_given?
       puts "Skipped #{red(token)}"
     end
 
-    def handle_help(token) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def handle_help(token, suggestions) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       clear_line(2)
       puts ''
+      if suggestions.length > 1
+        puts "#{key '1'}...#{key suggestions.length.to_s} "\
+          "Replace #{red token} with the numbered suggestion"
+      elsif suggestions.length == 1
+        puts "#{key '1'} Replace #{red token} with the numbered suggestion"
+      end
       puts "#{key 'a'} Add #{red token} to a word list"
       puts "#{key 'r'} Replace #{red token}"
       puts "#{key 'R'} Replace this and all future instances of #{red token}"
@@ -160,7 +197,7 @@ module Spellr
       puts "[ctrl] + #{key 'C'} Exit spellr"
       puts ''
       print "What do you want to do? [ ]\e[2D"
-      handle_response(token)
+      handle_response(token, suggestions)
     end
   end
 end

data/lib/spellr/interactive_add.rb

@@ -39,8 +39,8 @@ module Spellr
     end
 
     def handle_ctrl_c
-      reporter.clear_line(language_keys.length + 6)
-      reporter.call(token)
+      reporter.clear_line(language_keys.length + 5)
+      reporter.call(token, only_prompt: true)
     end
 
     def handle_wordlist_choice

data/lib/spellr/interactive_replacement.rb

@@ -70,8 +70,8 @@ module Spellr
 
     def handle_ctrl_c
       print "\e[0m"
-      reporter.clear_line(5)
-      reporter.call(token)
+      reporter.clear_line(4)
+      reporter.call(token, only_prompt: true)
     end
 
     private

data/lib/spellr/key_tuner/possible_key.rb

@@ -79,7 +79,7 @@ class PossibleKey # rubocop:disable Metrics/ClassLength
     letter_frequency_difference.slice(*FEATURE_LETTERS)
   end
 
-  def character_set # rubocop:disable Metrics/MethodLength
+  def character_set
     @character_set ||= case string
     when /^[a-fA-F0-9\-]+$/ then :hex
     when /^[a-z0-9]+$/ then :lower36

data/lib/spellr/key_tuner/stats.rb

@@ -27,7 +27,7 @@ module Stats
     yield values.max_by(&block)
   end
 
-  def variance(values, &block) # rubocop:disable Metrics/MethodLength
+  def variance(values, &block)
     return 0 if values.empty?
 
     mean = mean(values, &block)

data/lib/spellr/line_tokenizer.rb

@@ -37,7 +37,7 @@ module Spellr
       end
     end
 
-    def each_token(skip_term_proc: nil) # rubocop:disable Metrics/MethodLength
+    def each_token(skip_term_proc: nil)
       until eos?
         term = next_term
         next unless term

data/lib/spellr/rake_task.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'rake'
-require 'spellr/cli'
 require 'shellwords'
 
 module Spellr
@@ -36,11 +35,13 @@ module Spellr
       desc("Run spellr (default args: #{escaped_argv})")
     end
 
-    def define_task
+    def define_task # rubocop:disable Metrics/MethodLength
       task(@name, :'*args') do |_, task_argv|
-        argv = argv_or_default(task_argv)
-        write_cli_cmd(argv)
-        run(argv)
+        with_utf_8 do
+          argv = argv_or_default(task_argv)
+          write_cli_cmd(argv)
+          run(argv)
+        end
       end
     end
 
@@ -49,6 +50,7 @@ module Spellr
     end
 
     def run(argv)
+      require 'spellr/cli'
       status = Spellr::CLI.new(argv).run
       exit 1 unless status == 0
     end
@@ -57,5 +59,15 @@ module Spellr
       task_argv = task_argv.to_a.compact
       task_argv.empty? ? @default_argv : task_argv
     end
+
+    def with_utf_8 # rubocop:disable Metrics/MethodLength
+      old_default_external = ::Encoding.default_external
+      old_default_internal = ::Encoding.default_internal
+      ::Encoding.default_external = ::Encoding::UTF_8
+      ::Encoding.default_internal = ::Encoding::UTF_8
+      yield
+      ::Encoding.default_external = old_default_external
+      ::Encoding.default_internal = old_default_internal
+    end
   end
 end

data/lib/spellr/reporter.rb

@@ -7,8 +7,8 @@ module Spellr
   class Reporter < Spellr::BaseReporter
     def finish
       puts "\n"
-      puts "#{pluralize 'file', counts[:checked]} checked"
-      puts "#{pluralize 'error', counts[:total]} found"
+      print_count(:checked, 'file')
+      print_count(:total, 'error', 'found')
 
       interactive_command if counts[:total].positive?
     end

data/lib/spellr/suggester.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'did_you_mean'
+require 'jaro_winkler'
+
+::DidYouMean.send(:remove_const, :JaroWinkler)
+::DidYouMean::JaroWinkler = ::JaroWinkler
+
+module Spellr
+  class Suggester
+    class << self
+      def suggestions(token)
+        wordlists = token.location.file.wordlists
+        term = token.spellr_normalize.chomp
+        words = wordlists.flat_map { |wordlist| wordlist.suggestions(token) }.uniq
+        words = ::DidYouMean::SpellChecker.new(dictionary: words).correct(term)
+        words = reduce_suggestions(words, term)
+
+        words.map { |word| word.send(token.case_method) }
+      end
+
+      def slow?
+        return @slow if defined?(@slow)
+
+        @slow = ::JaroWinkler.method(:distance).source_location
+      end
+
+      def fast_suggestions(token)
+        if slow?
+          []
+        else
+          suggestions(token)
+        end
+      end
+
+      private
+
+      def reduce_suggestions(words, term)
+        return words unless words.length > 1
+
+        threshold = ::JaroWinkler.distance(term, words.first) * 0.98
+        words.select! { |word| ::JaroWinkler.distance(term, word) > threshold }
+        words.sort_by! { |word| [-::JaroWinkler.distance(term, word), word] }
+        words.take(5)
+      end
+    end
+
+    def initialize(wordlist)
+      @did_you_mean = ::DidYouMean::SpellChecker.new(dictionary: wordlist.to_a)
+      @suggestions = {}
+    end
+
+    def suggestions(term)
+      term = term.spellr_normalize
+      @suggestions.fetch(term) do
+        @suggestions[term] = @did_you_mean.correct(term).map(&:chomp)
+      end
+    end
+  end
+end

data/lib/spellr/token.rb

@@ -66,5 +66,14 @@ module Spellr
       @replacement = replacement
       location.file.insert(replacement, file_char_range)
     end
+
+    def case_method
+      @case_method ||= case self
+      when /\A[[:lower:]]+\z/ then :downcase
+      when /\A[[:upper:]]+\z/ then :upcase
+      when /\A[[:upper:]][[:lower:]]*\z/ then :capitalize
+      else :itself
+      end
+    end
   end
 end

data/lib/spellr/tokenizer.rb

@@ -27,14 +27,14 @@ module Spellr
     end
 
     def each_term(&block)
-      file.each_line(encoding: ::Encoding::UTF_8) do |line|
+      file.each_line do |line|
         prepare_tokenizer_for_line(line)&.each_term(&block)
       end
     ensure
       file.close
     end
 
-    def each_token(skip_term_proc: nil) # rubocop:disable Metrics/MethodLength
+    def each_token(skip_term_proc: nil)
       each_line_with_stats do |line, line_number, char_offset, byte_offset|
         prepare_tokenizer_for_line(line)&.each_token(skip_term_proc: skip_term_proc) do |token|
           token.line = prepare_line(line, line_number, char_offset, byte_offset)
@@ -56,14 +56,12 @@ module Spellr
       char_offset = @start_at.line_location.char_offset
       byte_offset = @start_at.line_location.byte_offset
 
-      file
-        .each_line(encoding: ::Encoding::UTF_8)
-        .with_index(@start_at.line_location.line_number) do |line, line_number|
-          yield line, line_number, char_offset, byte_offset
+      file.each_line.with_index(@start_at.line_location.line_number) do |line, line_number|
+        yield line, line_number, char_offset, byte_offset
 
-          char_offset += line.length
-          byte_offset += line.bytesize
-        end
+        char_offset += line.length
+        byte_offset += line.bytesize
+      end
     ensure
       file.close
     end

data/lib/spellr/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spellr
-  VERSION = '0.9.0'
+  VERSION = '0.10.1'
 end

data/lib/spellr/wordlist.rb

@@ -41,7 +41,7 @@ module Spellr
       touch
       @include[term] = true
       insert_sorted(term)
-      @path.write(words.join, encoding: ::Encoding::UTF_8) # we don't need to clear the cache
+      @path.write(words.join) # we don't need to clear the cache
     end
 
     def words
@@ -55,7 +55,7 @@ module Spellr
     end
 
     def write(content)
-      @path.write(content, encoding: ::Encoding::UTF_8)
+      @path.write(content)
 
       clear_cache
     end
@@ -70,7 +70,7 @@ module Spellr
       return if exist?
 
       @path.dirname.mkpath
-      @path.write('', encoding: ::Encoding::UTF_8)
+      @path.write('')
       clear_cache
     end
 
@@ -78,8 +78,20 @@ module Spellr
       to_a.length
     end
 
+    def suggestions(term)
+      suggester.suggestions(term)
+    end
+
     private
 
+    def suggester
+      @suggester ||= begin
+        require_relative 'suggester'
+
+        ::Spellr::Suggester.new(self)
+      end
+    end
+
     def insert_sorted(term)
       insert_at = words.bsearch_index { |value| value >= term }
       insert_at ? words.insert(insert_at, term) : words.push(term)
@@ -87,6 +99,7 @@ module Spellr
 
     def clear_cache
       @words = nil
+      @suggester = nil
       @include = {}
       remove_instance_variable(:@exist) if defined?(@exist)
     end

data/spellr.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
     spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
   end
 
-  spec.required_ruby_version = '>= 2.4'
+  spec.required_ruby_version = '>= 2.5'
 
   spec.files = Dir.glob('{lib,exe,wordlists}/**/{*,.*}') + %w{
     CHANGELOG.md
@@ -47,6 +47,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'tty_string', '>= 1.1.0'
   spec.add_development_dependency 'webmock', '~> 3.8'
 
+  spec.add_dependency 'did_you_mean'
   spec.add_dependency 'fast_ignore', '>= 0.11.0'
+  spec.add_dependency 'jaro_winkler'
   spec.add_dependency 'parallel', '~> 1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spellr
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Dana Sherson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-06-10 00:00:00.000000000 Z
+date: 2022-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -192,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: did_you_mean
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fast_ignore
   requirement: !ruby/object:Gem::Requirement
@@ -206,6 +220,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: jaro_winkler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -235,12 +263,11 @@ files:
 - exe/spellr
 - lib/.spellr.yml
 - lib/spellr.rb
+- lib/spellr/autocorrect_reporter.rb
 - lib/spellr/backports.rb
 - lib/spellr/base_reporter.rb
 - lib/spellr/check.rb
 - lib/spellr/check_dry_run.rb
-- lib/spellr/check_interactive.rb
-- lib/spellr/check_parallel.rb
 - lib/spellr/cli.rb
 - lib/spellr/cli_options.rb
 - lib/spellr/column_location.rb
@@ -266,7 +293,7 @@ files:
 - lib/spellr/rake_task.rb
 - lib/spellr/reporter.rb
 - lib/spellr/string_format.rb
-- lib/spellr/stringio_with_encoding.rb
+- lib/spellr/suggester.rb
 - lib/spellr/token.rb
 - lib/spellr/token_regexps.rb
 - lib/spellr/tokenizer.rb
@@ -312,7 +339,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/spellr/check_interactive.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spellr'
-require_relative 'check'
-
-module Spellr
-  class CheckInteractive < Check
-    private
-
-    def check_file_from_restart(file, restart_token, wordlist_proc)
-      # new wordlist cache when adding a word
-      wordlist_proc = wordlist_proc_for(file) unless restart_token.replacement
-      check_file(file, restart_token.location, wordlist_proc)
-    end
-
-    def check_file(file, start_at = nil, wordlist_proc = wordlist_proc_for(file))
-      restart_token = catch(:check_file_from) do
-        super(file, start_at, wordlist_proc)
-        nil
-      end
-      check_file_from_restart(file, restart_token, wordlist_proc) if restart_token
-    end
-  end
-end

data/lib/spellr/check_parallel.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../spellr'
-require_relative 'check'
-require_relative 'output_stubbed'
-require 'parallel'
-
-module Spellr
-  class CheckParallel < Check
-    def check # rubocop:disable Metrics/MethodLength
-      acc_reporter = @reporter
-
-      Parallel.each(files, finish: ->(_, _, result) { acc_reporter.output << result }) do |file|
-        @reporter = acc_reporter.class.new(Spellr::OutputStubbed.new)
-        check_and_count_file(file)
-        reporter.output
-      end
-      @reporter = acc_reporter
-
-      reporter.finish
-    end
-  end
-end

data/lib/spellr/stringio_with_encoding.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Spellr
-  class StringIOWithEncoding < ::StringIO
-    def each_line(*args, encoding: nil, **kwargs, &block)
-      string.force_encoding(encoding) if encoding && !string.frozen?
-
-      super(*args, **kwargs, &block)
-    end
-  end
-end