spellr 0.1.0

data/lib/spellr/check.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../spellr'
+require_relative 'tokenizer'
+require_relative 'token'
+require_relative 'column_location'
+require_relative 'line_location'
+
+module Spellr
+  class InvalidByteSequence
+    def self.===(error)
+      error.is_a?(ArgumentError) &&
+        /invalid byte sequence/.match?(error.message)
+    end
+  end
+
+  class Check
+    attr_reader :exit_code
+    attr_reader :files, :reporter
+
+    def initialize(files: [], reporter: Spellr.config.reporter)
+      @files = files
+      @reporter = reporter
+      @exit_code = 0
+    end
+
+    def check
+      checked = 0
+      files.each do |file|
+        check_file(file)
+        checked += 1
+      rescue InvalidByteSequence
+        # sometimes files are binary
+        puts "Skipped unreadable file: #{file}" unless Spellr.config.quiet?
+      end
+
+      reporter.finish(checked) if reporter.respond_to?(:finish)
+    end
+
+    private
+
+    def check_file(file, start_at: nil, wordlists: Spellr.config.wordlists_for(file))
+      Spellr::Tokenizer.new(file, start_at: start_at).each_token do |token|
+        next if wordlists.any? { |d| d.include?(token) }
+
+        start_at = token.location
+        reporter.call(token)
+        @exit_code = 1
+      end
+    rescue Spellr::DidReplacement => e # Yeah this is exceptions for control flow, but it makes sense to me
+      check_file(file, start_at: e.token.location, wordlists: wordlists)
+    rescue Spellr::DidAdd => e
+      check_file(file, start_at: e.token.location) # don't cache the wordlists
+    end
+  end
+end

data/lib/spellr/cli.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'pathname'
+require 'open3'
+
+require_relative '../spellr'
+
+module Spellr
+  class CLI # rubocop:disable Metrics/ClassLength
+    attr_writer :fetch_output_dir
+    attr_reader :argv
+
+    def initialize(argv)
+      @argv = argv
+
+      parse_command
+    end
+
+    def check
+      require_relative 'check'
+      checker = Spellr::Check.new(files: files)
+      checker.check
+
+      exit checker.exit_code
+    end
+
+    def files
+      require_relative 'file_list'
+      Spellr::FileList.new(*argv)
+    end
+
+    def wordlist_option(_)
+      require_relative 'wordlist_reporter'
+      Spellr.config.reporter = Spellr::WordlistReporter.new
+    end
+
+    def quiet_option(_)
+      Spellr.config.quiet = true
+      Spellr.config.reporter = ->(_) {}
+    end
+
+    def interactive_option(_)
+      require_relative 'interactive'
+      Spellr.config.reporter = Spellr::Interactive.new
+    end
+
+    def config_option(file)
+      Spellr.config.config_file = Pathname.pwd.join(file).expand_path
+    end
+
+    def dry_run_option(_)
+      files.each { |f| puts f.relative_path_from(Pathname.pwd) }
+
+      exit
+    end
+
+    def version_option(_)
+      require_relative 'version'
+      puts(Spellr::VERSION)
+
+      exit
+    end
+
+    def get_wordlist_option(command)
+      get_wordlist_dir.join(command)
+    end
+
+    def fetch_output_dir
+      @fetch_output_dir ||= Pathname.pwd.join('.spellr_wordlists/generated').expand_path
+    end
+
+    def fetch_words_for_wordlist(wordlist)
+      wordlist_command(wordlist, *argv)
+    end
+
+    def wordlist_command(wordlist, *args)
+      require 'shellwords'
+      command = fetch_wordlist_dir.join(wordlist).to_s
+      fetch_output_dir.mkpath
+
+      command_with_args = args.unshift(command).shelljoin
+
+      out, err, status = Open3.capture3(command_with_args)
+      puts err unless err.empty?
+      return out if status.exitstatus == 0
+
+      exit
+    end
+
+    def replace_wordlist(words, wordlist)
+      require_relative '../../lib/spellr/wordlist'
+
+      Spellr::Wordlist.new(fetch_output_dir.join("#{wordlist}.txt")).clean(StringIO.new(words))
+    end
+
+    def extract_and_write_license(words, wordlist)
+      words, license = words.split('---', 2).reverse
+
+      fetch_output_dir.join("#{wordlist}.LICENSE.txt").write(license) if license
+
+      words
+    end
+
+    def fetch
+      wordlist = argv.shift
+      puts "Fetching #{wordlist} wordlist"
+      words = fetch_words_for_wordlist(wordlist)
+      puts "Preparing #{wordlist} wordlist"
+      words = extract_and_write_license(words, wordlist)
+      puts "cleaning #{wordlist} wordlist"
+      replace_wordlist(words, wordlist)
+    end
+
+    def output_option(dir)
+      self.fetch_output_dir = Pathname.pwd.join(dir).expand_path
+    end
+
+    def wordlists
+      fetch_wordlist_dir.children.map { |p| p.basename.to_s }
+    end
+
+    def fetch_wordlist_dir
+      @fetch_wordlist_dir ||= Pathname.new(__dir__).parent.parent.join('bin', 'fetch_wordlist').expand_path
+    end
+
+    def parse_command
+      case argv.first
+      when 'fetch'
+        parse_fetch_options
+        fetch
+      else
+        parse_options
+        check
+      end
+    end
+
+    def fetch_options
+      @fetch_options ||= begin
+        opts = OptionParser.new
+        opts.banner = "Usage: spellr fetch [options] WORDLIST [wordlist options]\nAvailable wordlists: #{wordlists}"
+
+        opts.separator('')
+        opts.on('-o', '--output=OUTPUT', 'Outputs the fetched wordlist to OUTPUT/WORDLIST.txt', &method(:output_option))
+        opts.on('-h', '--help', 'Shows help for fetch', &method(:fetch_options_help))
+
+        opts
+      end
+    end
+
+    def fetch_options_help(*_)
+      puts fetch_options.help
+
+      wordlist = argv.first
+      if wordlist
+        puts
+        wordlist_command('english', '--help')
+      end
+
+      exit
+    end
+
+    def options_help(_)
+      puts options.help
+      puts
+      puts fetch_options.help
+
+      exit
+    end
+
+    def parse_options
+      options.parse!(argv)
+    end
+
+    def parse_fetch_options
+      argv.shift
+      fetch_options.order!(argv) do |non_arg|
+        argv.unshift(non_arg)
+        break
+      end
+    end
+
+    def options # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      @options ||= begin
+        opts = OptionParser.new
+
+        opts.banner = 'Usage: spellr [options] [files]'
+        opts.separator('')
+        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.separator('')
+        opts.on('-d', '--dry-run', 'List files to be checked', &method(:dry_run_option))
+        opts.separator('')
+        opts.on('-c', '--config FILENAME', String, <<~HELP, &method(:config_option))
+          Path to the config file (default ./.spellr.yml)
+        HELP
+        opts.on('-v', '--version', 'Returns the current version', &method(:version_option))
+        opts.on('-h', '--help', 'Shows this message', &method(:options_help))
+
+        opts
+      end
+    end
+  end
+end

data/lib/spellr/column_location.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'line_location'
+
+module Spellr
+  class ColumnLocation
+    attr_reader :line_location
+    attr_reader :char_offset
+    attr_reader :byte_offset
+
+    def initialize(char_offset: 0, byte_offset: 0, line_location: LineLocation.new)
+      @line_location = line_location
+      @char_offset = char_offset
+      @byte_offset = byte_offset
+    end
+
+    def absolute_char_offset
+      char_offset + line_location.char_offset
+    end
+
+    def absolute_byte_offset
+      byte_offset + line_location.byte_offset
+    end
+
+    def line_number
+      line_location.line_number
+    end
+
+    def file
+      line_location.file
+    end
+
+    def file_name
+      line_location.file_name
+    end
+
+    def to_s
+      "#{line_location}:#{char_offset}"
+    end
+
+    def inspect
+      "#<#{self.class.name} #{self}>"
+    end
+
+    def coordinates
+      [line_number, char_offset]
+    end
+  end
+end

data/lib/spellr/config.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative '../spellr'
+
+module Spellr
+  class Config
+    attr_writer :reporter
+    attr_reader :config_file
+    attr_accessor :quiet
+    alias_method :quiet?, :quiet
+
+    def initialize
+      @config_file = ::File.join(Dir.pwd, '.spellr.yml')
+      load_config
+    end
+
+    def word_minimum_length
+      @config[:word_minimum_length]
+    end
+
+    def only
+      @config[:only] || []
+    end
+
+    def ignored
+      @config[:ignore]
+    end
+
+    def color
+      @config[:color]
+    end
+
+    def clear_cache
+      remove_instance_variable(:@wordlists) if defined?(@wordlists)
+      remove_instance_variable(:@languages) if defined?(@languages)
+    end
+
+    def languages
+      require_relative 'language'
+
+      @languages ||= @config[:languages].map do |key, args|
+        [key, Spellr::Language.new(key, args)]
+      end.to_h
+    end
+
+    def languages_for(file)
+      languages.values.select { |l| l.matches?(file) }
+    end
+
+    def wordlists
+      @wordlists ||= languages.values.flat_map(&:wordlists)
+    end
+
+    def all_wordlist_paths
+      languages.values.flat_map(&:all_wordlist_paths)
+    end
+
+    def wordlists_for(file)
+      languages_for(file).flat_map(&:wordlists)
+    end
+
+    def config_file=(value)
+      ::File.read(value) # raise Errno::ENOENT if the file doesn't exist
+      @config_file = value
+      load_config
+    end
+
+    def reporter
+      @reporter ||= default_reporter
+    end
+
+    private
+
+    def default_reporter
+      require_relative 'reporter'
+
+      Spellr::Reporter.new
+    end
+
+    def load_config
+      default_config = load_yaml(::File.join(__dir__, '..', '.spellr.yml'))
+      project_config = load_yaml(config_file)
+
+      @config = merge_config(default_config, project_config)
+    end
+
+    def load_yaml(path)
+      require 'yaml'
+
+      return {} unless ::File.exist?(path)
+
+      YAML.safe_load(::File.read(path), symbolize_names: true)
+    end
+
+    def merge_config(default, project)
+      if project.is_a?(Array) && default.is_a?(Array)
+        default | project
+      elsif project.is_a?(Hash) && default.is_a?(Hash)
+        default.merge(project) { |_k, d, p| merge_config(d, p) }
+      else
+        project
+      end
+    end
+  end
+end

data/lib/spellr/file.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Spellr
+  class File < Pathname
+    def self.wrap(file)
+      file.is_a?(Spellr::File) ? file : Spellr::File.new(file)
+    end
+
+    def hashbang
+      return if extname != ''
+      return unless first_line&.start_with?('#!')
+
+      first_line
+    end
+
+    def first_line
+      @first_line ||= each_line.first
+    end
+
+    def fnmatch?(pattern)
+      relative_path_from(Pathname.pwd).fnmatch?(pattern, ::File::FNM_DOTMATCH) ||
+        Pathname.new(basename).fnmatch?(pattern, ::File::FNM_DOTMATCH)
+    end
+  end
+end

data/lib/spellr/file_list.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'fast_ignore'
+require_relative '../spellr'
+require_relative 'file'
+
+module Spellr
+  class FileList
+    include Enumerable
+
+    def initialize(*patterns)
+      @patterns = patterns
+    end
+
+    def wordlist?(file)
+      Spellr.config.all_wordlist_paths.any? { |w| w == file }
+    end
+
+    def config_only?(file)
+      Spellr.config.only.empty? || Spellr.config.only.any? { |o| file.fnmatch?(o) }
+    end
+
+    def cli_only?(file)
+      @patterns.empty? || @patterns.any? { |p| file.fnmatch?(p) }
+    end
+
+    def each
+      # TODO: handle no gitignore
+      gitignore = ::File.join(Dir.pwd, '.gitignore')
+      gitignore = nil unless ::File.exist?(gitignore)
+      FastIgnore.new(rules: Spellr.config.ignored, gitignore: gitignore).each do |file|
+        file = Spellr::File.new(file)
+        next unless cli_only?(file)
+        next if wordlist?(file)
+        next unless config_only?(file)
+
+        yield(file)
+      end
+    end
+
+    def to_a
+      enum_for(:each).to_a
+    end
+  end
+end