spellr 0.6.0 → 0.7.0

data/lib/spellr/config.rb

@@ -3,38 +3,22 @@
 require_relative '../spellr'
 require_relative 'config_loader'
 require_relative 'language'
-require_relative 'reporter'
+require_relative 'config_validator'
 require 'pathname'
 
 module Spellr
   class Config
     attr_writer :reporter
+    attr_writer :checker
     attr_reader :config_file
     attr_accessor :quiet
     alias_method :quiet?, :quiet
+    attr_accessor :dry_run
 
     def initialize
       @config = ConfigLoader.new
     end
 
-    def valid?
-      only_has_one_key_per_language
-      keys_are_single_characters
-      errors.empty?
-    end
-
-    def print_errors
-      if $stderr.tty?
-        errors.each { |e| warn "\e[31m#{e}\e[0m" }
-      else
-        errors.each { |e| warn e }
-      end
-    end
-
-    def errors
-      @errors ||= []
-    end
-
     def word_minimum_length
       @word_minimum_length ||= @config[:word_minimum_length]
     end
@@ -55,10 +39,6 @@ module Spellr
       @excludes ||= @config[:excludes] || []
     end
 
-    def color
-      @config[:color]
-    end
-
     def languages
       @languages ||= @config[:languages].map do |key, args|
         Spellr::Language.new(key, **args)
@@ -66,7 +46,11 @@ module Spellr
     end
 
     def pwd
-      @pwd ||= Pathname.pwd
+      @pwd ||= Pathname.new(ENV['SPELLR_TEST_PWD'] || Dir.pwd)
+    end
+
+    def pwd_s
+      @pwd_s ||= pwd.to_s
     end
 
     def languages_for(file)
@@ -78,7 +62,7 @@ module Spellr
     end
 
     def config_file=(value)
-      ::File.read(value) # raise Errno::ENOENT if the file doesn't exist
+      reset!
       @config = ConfigLoader.new(value)
     end
 
@@ -86,32 +70,46 @@ module Spellr
       @reporter ||= default_reporter
     end
 
-    private
+    def checker
+      return dry_run_checker if @dry_run
 
-    def only_has_one_key_per_language
-      languages_with_conflicting_keys.each do |conflicts|
-        errors << "Error: #{conflicts.map(&:name).join(' & ')} share the same language key "\
-        "(#{conflicts.first.key}). Please define one to be different with `key:`"
-      end
+      @checker ||= default_checker
     end
 
-    def languages_with_conflicting_keys
-      languages.select(&:addable?).group_by(&:key).values.select do |g|
-        g.length > 1
-      end
+    def valid?
+      Spellr::ConfigValidator.new.valid?
     end
 
-    def keys_are_single_characters
-      bad_languages = languages.select { |l| l.key.length > 1 }
+    def reset! # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      @config = ConfigLoader.new
+      remove_instance_variable(:@languages) if defined?(@languages)
+      remove_instance_variable(:@excludes) if defined?(@excludes)
+      remove_instance_variable(:@includes) if defined?(@includes)
+      remove_instance_variable(:@word_minimum_length) if defined?(@word_minimum_length)
+      remove_instance_variable(:@key_heuristic_weight) if defined?(@key_heuristic_weight)
+      remove_instance_variable(:@key_minimum_length) if defined?(@key_minimum_length)
+    end
 
-      bad_languages.each do |language|
-        errors << "Error: #{language.name} defines a key that is too long (#{language.key}). "\
-          'Please change it to be a single character'
-      end
+    private
+
+    def dry_run_checker
+      require_relative 'check_dry_run'
+      Spellr::CheckDryRun
     end
 
     def default_reporter
+      require_relative 'reporter'
       Spellr::Reporter.new
     end
+
+    def default_checker
+      require_relative 'check_parallel'
+      Spellr::CheckParallel
+    end
+
+    def clear_pwd
+      remove_instance_variable(:@pwd) if defined?(@pwd)
+      remove_instance_variable(:@pwd_s) if defined?(@pwd_s)
+    end
   end
 end

data/lib/spellr/config_loader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'yaml'
+require_relative 'backports'
 
 module Spellr
   class ConfigLoader
@@ -10,15 +11,8 @@ module Spellr
       @config_file = config_file
     end
 
-    def config_file=(value)
-      # TODO: nicer error message
-      ::File.read(value) # raise Errno::ENOENT if the file doesn't exist
-      @config_file = value
-      @config = nil
-    end
-
     def [](value)
-      load_config unless @config
+      load_config unless defined?(@config)
       @config[value]
     end
 
@@ -34,27 +28,7 @@ module Spellr
     def load_yaml(path)
       return {} unless ::File.exist?(path)
 
-      symbolize_yaml_safe_load(path)
-    end
-
-    def symbolize_yaml_safe_load(path)
-      if RUBY_VERSION >= '2.5'
-        YAML.safe_load(::File.read(path), symbolize_names: true)
-      else
-        symbolize_names!(YAML.safe_load(::File.read(path)))
-      end
-    end
-
-    def symbolize_names!(obj) # rubocop:disable Metrics/MethodLength
-      case obj
-      when Hash
-        obj.keys.each do |key|
-          obj[key.to_sym] = symbolize_names!(obj.delete(key))
-        end
-      when Array
-        obj.map! { |ea| symbolize_names!(ea) }
-      end
-      obj
+      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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative 'validations'
+require 'timeout'
+require 'io/console'
+
+module Spellr
+  class ConfigValidator
+    include Spellr::Validations
+
+    validate :checker_and_reporter_coexist
+    validate :interactive_is_interactive
+    validate :only_has_one_key_per_language
+    validate :languages_with_conflicting_keys
+    validate :keys_are_single_characters
+
+    def valid?
+      raise Spellr::Config::Invalid, errors.join("\n") unless super
+    end
+
+    def interactive_is_interactive # rubocop:disable Metrics/MethodLength
+      return unless Spellr.config.reporter.class.name == 'Spellr::Interactive'
+
+      # I have no idea how to check for this other than call it
+      Timeout.timeout(0.0000000000001) do
+        $stdin.getch
+      end
+    rescue Errno::ENOTTY, Errno::ENODEV
+      errors << 'CLI error: --interactive is unavailable in a non-interactive terminal'
+    rescue Timeout::Error
+      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
+    end
+
+    def only_has_one_key_per_language
+      languages_with_conflicting_keys.each do |conflicts|
+        errors << "Config error: #{conflicts.map(&:name).join(' & ')} share the same language key "\
+        "(#{conflicts.first.key}). Please define one to be different with `key:`"
+      end
+    end
+
+    def languages_with_conflicting_keys
+      Spellr.config.languages.select(&:addable?).group_by(&:key).values.select do |g|
+        g.length > 1
+      end
+    end
+
+    def keys_are_single_characters
+      bad_languages = Spellr.config.languages.select { |l| l.key.length > 1 }
+
+      bad_languages.each do |lang|
+        errors << "Config error: #{lang.name} defines a key that is too long (#{lang.key}). "\
+          'Please change it to be a single character'
+      end
+    end
+  end
+end

data/lib/spellr/file_list.rb

@@ -8,17 +8,15 @@ module Spellr
   class FileList
     include Enumerable
 
-    def initialize(*patterns)
+    def initialize(patterns = nil)
       @patterns = patterns
     end
 
     def each
-      fast_ignore.each do |file|
-        next unless cli_patterns_ignore.allowed?(file)
-
-        file = Spellr::File.new(file)
+      return enum_for(:each) unless block_given?
 
-        yield(file)
+      fast_ignore.each do |file|
+        yield(Spellr::File.new(file))
       end
     end
 
@@ -28,28 +26,13 @@ module Spellr
 
     private
 
-    # anchored patterns are significantly faster on large codebases
-    def cli_patterns
-      @patterns.map do |pattern|
-        pattern.sub(%r{^(?!(?:[/~*]|\.{1,2}/))}, '/')
-      end
-    end
-
-    def gitignore_path
-      gitignore = ::File.join(Dir.pwd, '.gitignore')
-      gitignore if ::File.exist?(gitignore)
-    end
-
-    def fast_ignore
+    def fast_ignore # rubocop:disable Metrics/MethodLength
       FastIgnore.new(
         ignore_rules: Spellr.config.excludes,
         include_rules: Spellr.config.includes,
-        gitignore: gitignore_path
+        argv_rules: @patterns,
+        root: Spellr.config.pwd_s
       )
     end
-
-    def cli_patterns_ignore
-      @cli_patterns_ignore ||= FastIgnore.new(include_rules: cli_patterns, gitignore: false)
-    end
   end
 end

data/lib/spellr/interactive.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
 require 'io/console'
-require 'readline'
 require_relative '../spellr'
 require_relative 'interactive_add'
 require_relative 'interactive_replacement'
 require_relative 'base_reporter'
 
 module Spellr
-  class Interactive < BaseReporter
-    def parallel?
-      false
-    end
-
+  class Interactive < BaseReporter # rubocop:disable Metrics/ClassLength
     def finish # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       puts "\n"
       puts "#{pluralize 'file', counts[:checked]} checked"
@@ -25,21 +20,17 @@ module Spellr
     end
 
     def global_replacements
-      @global_replacements ||= begin
-        counts[:global_replacements] = {} unless counts.key?(:global_replacements)
-        counts[:global_replacements]
-      end
+      @global_replacements ||= counts[:global_replacements] = {}
     end
 
     def global_skips
-      @global_skips ||= begin
-        counts[:global_skips] = [] unless counts.key?(:global_skips)
-        counts[:global_skips]
-      end
+      @global_skips ||= counts[:global_skips] = []
     end
 
     def call(token)
-      return if attempt_global_replacement(token)
+      # 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
@@ -47,24 +38,71 @@ module Spellr
       prompt(token)
     end
 
-    def stdin_getch
+    def prompt_for_key
+      print "[ ]\e[2D"
+    end
+
+    def loop_within(seconds) # rubocop:disable Metrics/MethodLength
+      # timeout is just because it gets stuck sometimes
+      Timeout.timeout(seconds * 10) do
+        start_time = monotonic_time
+        yield until start_time + seconds < monotonic_time
+      end
+    rescue Timeout::Error
+      # :nocov:
+      nil
+      # :nocov:
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def stdin_getch(legal_chars) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       choice = output.stdin.getch
-      clear_current_line
-      choice
+
+      if legal_chars.include?(choice)
+        puts "\e[0K#{bold print_keypress(choice)}]\e[1C"
+        choice
+      elsif choice == "\e" # mac sends \e[A when up is pressed. thanks.
+        print "\a"
+        loop_within(0.001) { output.stdin.getch }
+
+        stdin_getch(legal_chars)
+      else
+        print "\a"
+        stdin_getch(legal_chars)
+      end
     end
 
-    private
+    ALPHABET = ('A'..'Z').to_a.join
+    CTRL = ("\u0001".."\u0026").freeze
+    CTRL_STR = CTRL.to_a.join
+    def print_keypress(char)
+      return char unless CTRL.cover?(char)
 
-    def total
-      counts[:total_skipped] + counts[:total_fixed] + counts[:total_added]
+      "^#{char.tr(CTRL_STR, ALPHABET)}"
     end
 
     def prompt(token)
-      print bold('[r,R,s,S,a,e,?]')
+      print "#{key 'add'}, #{key 'replace'}, #{key 'skip'}, #{key 'help'}, [^#{bold 'C'}] to exit: "
+      prompt_for_key
 
       handle_response(token)
-    rescue Interrupt
-      puts '^C again to exit'
+    end
+
+    def clear_line(lines = 1)
+      print "\r\e[K"
+      (lines - 1).times do
+        sleep 0.01
+        print "\r\e[1T\e[2K"
+      end
+    end
+
+    private
+
+    def total
+      counts[:total_skipped] + counts[:total_fixed] + counts[:total_added]
     end
 
     def attempt_global_skip(token)
@@ -83,15 +121,13 @@ module Spellr
       throw :check_file_from, token
     end
 
-    def clear_current_line
-      print "\r\e[K"
-    end
-
-    def handle_response(token) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-      case stdin_getch
-      when "\u0003" # ctrl c
+    def handle_response(token) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # :nocov:
+      case stdin_getch("qaAsSrR?h\u0003\u0004")
+      # :nocov:
+      when 'q', "\u0003" # ctrl c
         exit 1
-      when 'a'
+      when 'a', 'A'
         Spellr::InteractiveAdd.new(token, self)
       when 's', "\u0004" # ctrl d
         handle_skip(token)
@@ -101,13 +137,8 @@ module Spellr
         Spellr::InteractiveReplacement.new(token, self).global_replace
       when 'r'
         Spellr::InteractiveReplacement.new(token, self).replace
-      when 'e'
-        Spellr::InteractiveReplacement.new(token, self).replace_line
-      when '?'
+      when '?', 'h'
         handle_help(token)
-      else
-        clear_current_line
-        call(token)
       end
     end
 
@@ -118,13 +149,17 @@ module Spellr
     end
 
     def handle_help(token) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      puts "#{bold '[r]'} Replace #{red token}"
-      puts "#{bold '[R]'} Replace all future instances of #{red token}"
-      puts "#{bold '[s]'} Skip #{red token}"
-      puts "#{bold '[S]'} Skip all future instances of #{red token}"
-      puts "#{bold '[a]'} Add #{red token} to a word list"
-      puts "#{bold '[e]'} Edit the whole line"
-      puts "#{bold '[?]'} Show this help"
+      clear_line(2)
+      puts ''
+      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}"
+      puts "#{key 's'} Skip #{red token}"
+      puts "#{key 'S'} Skip this and all future instances of #{red token}"
+      puts "#{key 'h'} Show this help"
+      puts "[ctrl] + #{key 'C'} Exit spellr"
+      puts ''
+      print "What do you want to do? [ ]\e[2D"
       handle_response(token)
     end
   end

data/lib/spellr/interactive_add.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../spellr'
 require_relative 'string_format'
 
 module Spellr
@@ -12,6 +13,7 @@ module Spellr
       @token = token
       @reporter = reporter
 
+      puts ''
       ask_wordlist
     end
 
@@ -28,39 +30,41 @@ module Spellr
     end
 
     def ask_wordlist
-      puts "Add #{red(token)} to wordlist:"
+      addable_languages.each { |l| puts "  #{key l.key} #{l.name}" }
+      puts "  [^#{bold 'C'}] to go back"
+      print "  Add #{red(token)} to which wordlist? "
+      reporter.prompt_for_key
 
-      addable_languages.each do |language|
-        puts "[#{language.key}] #{language.name}"
-      end
-
-      handle_wordlist_choice(reporter.stdin_getch)
+      handle_wordlist_choice
     end
 
     def handle_ctrl_c
-      puts '^C again to exit'
+      reporter.clear_line(language_keys.length + 6)
       reporter.call(token)
     end
 
-    def handle_wordlist_choice(choice) # rubocop:disable Metrics/MethodLength
+    def handle_wordlist_choice
+      choice = reporter.stdin_getch("#{language_keys.join}\u0003")
+      # :nocov:
       case choice
-      when "\u0003"
-        handle_ctrl_c
-      when *language_keys
-        add_to_wordlist(choice)
-      else
-        ask_wordlist
+      # :nocov:
+      when "\u0003" then handle_ctrl_c
+      when *language_keys then add_to_wordlist(choice)
       end
     end
 
     def add_to_wordlist(choice)
-      wordlist = addable_languages.find { |w| w.key == choice }.project_wordlist
+      wordlist = find_wordlist(choice)
       wordlist << token
       reporter.increment(:total_added)
-      puts "Added #{red(token)} to #{wordlist.name} wordlist"
+      puts "\nAdded #{red(token)} to the #{bold wordlist.name} wordlist"
       throw :check_file_from, token
     end
 
+    def find_wordlist(key)
+      addable_languages.find { |w| w.key == key }.project_wordlist
+    end
+
     def puts(str)
       reporter.puts(str)
     end

data/lib/spellr/interactive_replacement.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
 
+require 'readline'
+require_relative 'string_format'
+
 module Spellr
   class InteractiveReplacement
     include Spellr::StringFormat
 
-    attr_reader :token, :reporter, :original_token, :token_highlight, :suffix
+    attr_reader :token, :reporter, :token_highlight
+    attr_accessor :global
+    alias_method :global?, :global
 
     def initialize(token, reporter)
-      @original_token = @token = token
+      @token = token
       @token_highlight = red(token)
       @reporter = reporter
       Readline.input = reporter.output.stdin
@@ -15,51 +20,69 @@ module Spellr
     end
 
     def global_replace
-      replace { |replacement| reporter.global_replacements[token.to_s] = replacement }
-    end
-
-    def replace_line
-      @token = token.line
-      @token_highlight = token.highlight(original_token.char_range).chomp
-      @suffix = "\n"
-
+      self.global = true
       replace
     end
 
     def complete_replacement(replacement)
-      token.replace("#{replacement}#{suffix}")
+      handle_global_replacement(replacement)
+      token.replace(replacement)
 
       reporter.increment(:total_fixed)
-      puts "Replaced #{red(token.chomp)} with #{green(replacement)}"
+      puts "\n\e[0mReplaced #{'all ' if global?}#{token_highlight} with #{green(replacement)}"
       throw :check_file_from, token
     end
 
-    def replace # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      readline_editable_print(token.chomp)
+    def handle_global_replacement(replacement)
+      reporter.global_replacements[token.to_s] = replacement if global?
+    end
 
-      puts "#{aqua '>>'} #{token_highlight}"
-      replacement = Readline.readline("#{aqua '=>'} ")
+    def ask_replacement
+      puts ''
+      puts "  #{lighten '[^C] to go back'}"
+      prompt_replacement
+    end
+
+    def prompt_replacement
+      Readline.pre_input_hook = -> { pre_input_hook(token) }
+      prompt = "  Replace #{'all ' if global?}#{token_highlight} with: \e[32m"
+      Readline.readline(prompt)
+    rescue Interrupt
+      handle_ctrl_c
+    end
 
-      return reporter.call(token) if replacement.empty?
+    def re_ask_replacement
+      print "\e[0m\a\e[1T"
+
+      try_replace(prompt_replacement)
+    end
+
+    def try_replace(replacement)
+      return re_ask_replacement if replacement == token
+      return re_ask_replacement if replacement.empty?
 
-      yield replacement if block_given?
       complete_replacement(replacement)
-    rescue Interrupt
-      puts '^C again to exit'
-      reporter.call(original_token)
+    end
+
+    def replace
+      try_replace(ask_replacement)
+    end
+
+    def handle_ctrl_c
+      print "\e[0m"
+      reporter.clear_line(5)
+      reporter.call(token)
     end
 
     private
 
-    def readline_editable_print(string) # rubocop:disable Metrics/MethodLength
-      Readline.pre_input_hook = lambda {
-        Readline.refresh_line
-        Readline.insert_text string.to_s
-        Readline.redisplay
+    def pre_input_hook(value)
+      Readline.refresh_line
+      Readline.insert_text value.to_s
+      Readline.redisplay
 
-        # Remove the hook right away.
-        Readline.pre_input_hook = nil
-      }
+      # Remove the hook right away.
+      Readline.pre_input_hook = nil
     end
 
     def puts(str)