gramrb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 658d4ce56f5e37c4c41f8cbda02d6aa7b203c75de901704179de3c32a31ca6af
+  data.tar.gz: ae6418357aab615ae1fbb5d5b0a4dc9873f4f678fc87f3e844c8e9a2684a65a1
+SHA512:
+  metadata.gz: 6846c62e554f806558933e96c1d146fda16ad4650634c28f575027eec07a4a130098723a6c6508a575383023e7e72f6a7ec5a2d635cff7ac02c01be9366701ce
+  data.tar.gz: 70c11c0844b85a40b8957a65339c1d8fcf7518422fe60be0051a59c12c5fafb80db51ee866dd0f36d411fd5815ebef22e41792b59c0f189f200858431a86a79f

data/bin/gramrb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/gramrb'
+
+case ARGV[0]
+when '--version', '-v'
+  puts Gramrb::Version::VERSION
+when '--help', '-h'
+  puts <<~HELP
+    Usage: gramrb [path]
+
+    Scans .rb files for spelling errors in variable names, method names, comments, and strings.
+
+    Options:
+      -v, --version    Print version
+      -h, --help       Print this help
+  HELP
+else
+  begin
+    Gramrb::CLI.new(ARGV[0]).run
+  rescue Errno::ENOENT, ArgumentError => e
+    puts "Error: #{e.message}"
+    exit 1
+  end
+end

data/lib/gramrb/cli.rb

@@ -0,0 +1,66 @@
+module Gramrb
+  class CLI
+    include Formatter
+
+    def initialize(path) = @path = path || '.'
+
+    def run
+      puts
+      results = scan_files
+      puts "\n"
+      print_results(results)
+    end
+
+    private
+
+    def scan_files
+      files.each_with_object({}) do |file, results|
+        results.merge!(FileScanner.new(file).scan)
+        print results.key?(file) ? red('F') : green('.')
+      end
+    end
+
+    def print_results(results)
+      puts "\nPossible spelling errors found:" if results.any?
+      results.each do |path, errors|
+        puts "#{cyan(path)} #{red("(#{pluralise(file_error_count(errors), 'error')})")}"
+
+        print_filename_errors(errors[:filename_errors])
+        print_content_errors(path, errors[:content_errors])
+      end
+
+      print_summary(total_errors(results))
+    end
+
+    def print_filename_errors(errors)
+      errors.each do |error|
+        puts "  - #{cyan('Filename: ')}#{highlight(error)} #{green(%{(Did you mean: "#{error[:suggestion]}"?)})}"
+      end
+    end
+
+    def print_content_errors(path, errors)
+      errors.each do |error|
+        puts "  - #{cyan(path)}:#{error[:line]} #{highlight(error)} #{green(%{(Did you mean: "#{error[:suggestion]}"?)})}"
+      end
+    end
+
+    def print_summary(total)
+      summary = "found #{pluralise(total, 'error')}"
+      puts "\n#{pluralise(files.count, 'file')} scanned, #{total.zero? ? green(summary) : red(summary)}"
+      puts yellow("\nTo ignore a word, add it to your .gramrb.yml allowlist.")
+      puts yellow('Think it should be in the master allowlist? Open an issue at https://github.com/Pandaman74/Gramrb/issues')
+    end
+
+    def highlight(error) = error[:item].gsub(error[:error], red(error[:error]))
+
+    def files
+      @files ||= File.file?(@path) ? [@path] : Dir.glob("#{@path}/**/*.rb").reject { |file| config.excluded.any? { |excluded| file.include?(excluded) } }
+    end
+
+    def config = @config ||= Config.new
+
+    def file_error_count(errors) = (errors[:filename_errors] + errors[:content_errors]).count
+
+    def total_errors(results) = results.values.sum { |errors| file_error_count(errors) }
+  end
+end

data/lib/gramrb/config.rb

@@ -0,0 +1,17 @@
+require 'yaml'
+module Gramrb
+  class Config
+    def allowlisted = (bundled['allowlist'] + (project['allowlist'] || [])).uniq
+
+    def excluded = project['excluded'] || bundled['excluded']
+
+    private
+
+    def bundled = YAML.load_file(File.join(__dir__, '../../config/.gramrb.yml'))
+
+    def project
+      path = File.join(Dir.pwd, '.gramrb.yml')
+      File.exist?(path) ? YAML.load_file(path) : {}
+    end
+  end
+end

data/lib/gramrb/content_extractor.rb

@@ -0,0 +1,28 @@
+module Gramrb
+  class ContentExtractor
+    def initialize(content) = @lines = content.lines
+
+    def extract_all = @lines.flat_map.with_index(1) { |line, line_number| extract_from_line(line, line_number) }
+
+    private
+
+    def extract_from_line(line, line_number)
+      @line = line
+      @line_number = line_number
+      extract_strings + extract_comments + extract_method_names + extract_variables + extract_symbols
+    end
+
+    def extract_strings = @line.scan(/['"]([^'"]*?)['"]/).map { |match| { text: match[0], line_number: @line_number } }
+
+    def extract_comments = @line.scan(/^\s*#\s*(.*)/).map { |match| { text: match[0], line_number: @line_number } }
+
+    def extract_method_names = @line.scan(/def\s+([a-zA-Z_]\w*)/).map { |match| { text: match[0], line_number: @line_number } }
+
+    def extract_variables = @line.scan(/(@?[a-zA-Z_]\w*)\s*=/).map { |match| { text: match[0], line_number: @line_number } }
+
+    def extract_symbols
+      @line.scan(/(:[a-zA-Z_]\w*)/).map { |match| { text: match[0], line_number: @line_number } } +
+        @line.scan(/([a-zA-Z_]\w*:)/).map { |match| { text: match[0], line_number: @line_number } }
+    end
+  end
+end

data/lib/gramrb/file_scanner.rb

@@ -0,0 +1,21 @@
+module Gramrb
+  class FileScanner
+    def initialize(path)
+      raise ArgumentError, ".#{File.extname(path)} files are not supported" if File.extname(path) != '.rb'
+
+      @path = path
+      @filename = File.basename(path, '.rb')
+      @content = ContentExtractor.new(File.read(path)).extract_all
+      @spell_checker = SpellChecker.new(Config.new.allowlisted)
+      @string_cleaner = StringCleaner.new
+    end
+
+    def scan = (filename_errors + content_errors).any? ? { @path => { filename_errors:, content_errors: } } : {}
+
+    private
+
+    def filename_errors = @spell_checker.check_words(@string_cleaner.clean_filename(@filename))
+
+    def content_errors = @spell_checker.check_words(@string_cleaner.clean_content(@content))
+  end
+end

data/lib/gramrb/formatter.rb

@@ -0,0 +1,13 @@
+module Gramrb
+  module Formatter
+    def pluralise(count, word) = "#{count} #{count == 1 ? word : "#{word}s"}"
+
+    def red(str) = "\e[31m#{str}\e[0m"
+
+    def green(str) = "\e[32m#{str}\e[0m"
+
+    def yellow(str) = "\e[33m#{str}\e[0m"
+
+    def cyan(str) = "\e[36m#{str}\e[0m"
+  end
+end

data/lib/gramrb/spell_checker.rb

@@ -0,0 +1,35 @@
+require 'tmpdir'
+
+module Gramrb
+  class SpellChecker
+    def initialize(allowlisted)
+      pws_path = File.join(Dir.tmpdir, 'gramrb.pws')
+      File.write(pws_path, "personal_ws-1.1 en 0\n#{allowlisted.join("\n")}")
+      @string_cleaner = StringCleaner.new
+      @speller_gb = FFI::Aspell::Speller.new('en_GB', personal: pws_path)
+      @speller_us = FFI::Aspell::Speller.new('en_US', personal: pws_path)
+    end
+
+    def check_words(content)
+      content.each_with_object([]) do |item, results|
+        bad_words(item[:words]).each do |error|
+          suggestion = @speller_us.suggestions(error).first || @speller_gb.suggestions(error).first
+          results << { item: item[:item], line: item[:line], error:, suggestion: }
+        end
+      end
+    end
+
+    private
+
+    def bad_words(words)
+      words.each_with_object([]) do |word, errors|
+        next if correct?(word)
+
+        parts = @string_cleaner.split_camel(word)
+        parts.length > 1 ? errors.concat(parts.reject { |part| correct?(part) }) : errors << word
+      end
+    end
+
+    def correct?(word) = @speller_us.correct?(word) || @speller_gb.correct?(word)
+  end
+end

data/lib/gramrb/string_cleaner.rb

@@ -0,0 +1,34 @@
+module Gramrb
+  class StringCleaner
+    def clean_filename(name) = [clean_item(name)]
+
+    def clean_content(content)
+      content.filter_map do |item|
+        cleaned = clean_item(item[:text])
+        cleaned[:line] = item[:line_number]
+        cleaned if cleaned[:words].any?
+      end
+    end
+
+    def split_camel(item) = item.gsub(/([a-z])([A-Z])/, '\1 \2').split.select { |word| word?(word) }
+
+    private
+
+    def clean_item(item)
+      return { item:, words: [] } if invalid?(item)
+
+      words = item.gsub(%r{https?://\S+}, ' ')
+                  .gsub(/([a-zA-Z])(\d)/, '\1 \2')
+                  .gsub(/(\d)([a-zA-Z])/, '\1 \2')
+                  .gsub(/[^a-zA-Z\s]/, ' ')
+                  .split
+                  .select { |word| word?(word) }
+
+      { item:, words: }
+    end
+
+    def invalid?(item) = item.nil? || item.empty?
+
+    def word?(word) = word.length > 1
+  end
+end

data/lib/gramrb/version.rb

@@ -0,0 +1,5 @@
+module Gramrb
+  module Version
+    VERSION = '1.0.0'.freeze
+  end
+end

data/lib/gramrb.rb

@@ -0,0 +1,10 @@
+require 'ffi/aspell'
+
+require_relative 'gramrb/formatter'
+require_relative 'gramrb/cli'
+require_relative 'gramrb/config'
+require_relative 'gramrb/content_extractor'
+require_relative 'gramrb/file_scanner'
+require_relative 'gramrb/spell_checker'
+require_relative 'gramrb/string_cleaner'
+require_relative 'gramrb/version'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: gramrb
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Pandaman74
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-aspell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: |
+  Gramrb is a spellchecking tool for Ruby code files, mostly for use within Ruby on Rails.
+  It uses Aspell to spellcheck aspects such as comments, method names, and variable names.
+email: pandamanprojects@gmail.com
+executables:
+- gramrb
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/gramrb
+- lib/gramrb.rb
+- lib/gramrb/cli.rb
+- lib/gramrb/config.rb
+- lib/gramrb/content_extractor.rb
+- lib/gramrb/file_scanner.rb
+- lib/gramrb/formatter.rb
+- lib/gramrb/spell_checker.rb
+- lib/gramrb/string_cleaner.rb
+- lib/gramrb/version.rb
+homepage: https://github.com/Pandaman74/Gramrb
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/Pandaman74/Gramrb
+  source_code_uri: https://github.com/Pandaman74/Gramrb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Spellchecker for .rb code files
+test_files: []